From 98f48f99876e325e23015968f7c77858918cf186 Mon Sep 17 00:00:00 2001 From: "Javier A. Ortiz Bultron" Date: Tue, 13 Jun 2017 17:01:59 -0500 Subject: [PATCH] Release version 0.3.3 (#57) * Change version to 0.4.1-SNAPSHOT. * Change version to 0.4.1-SNAPSHOT. Task #3 - Implement Trace Matrix * Use right version. * Copy over all fields when increasing the minor version. Task #29 - Baselining an item with major version > 0 resets to 0 * Add toString method with normal username and last name properly formatted. * Update from database. * prevent unnecessary versions while baselining. Task #30 - Baselining: Don't change the revision of an item not modified since last baseline * Fix various test issues along with bug (ommission) in code. Task #31 - Adding Test Case for execution didn't include Step text * Fix other bugs * Set size if there's something to show. * Fix issue where some Id's were not unique making them not show everywhere they needed to be. Task #32 - Trace Matrix: Test Cases don't show for all applicable Requirements * Removing dependence not used at this point. * Finish Trace Matrix implementation. Task #3 - Implement Trace Matrix * Implement internationalization. Task #5 - Allow full internationalization * Fix some issues in translations. * Add some locales. * Update VMMessages_es.properties (POEditor.com) * Implement date format setting. (#35) Task #11 - Add setting for date format * Add javadoc. * Implement internationalization. Task #5 - Allow full internationalization * Fix typo. * Add profile tab. Task #5 - Allow full internationalization * Fix missing translations. * Remove unused classes. * Translate component. * Add notification system. * More work in progress. Task #12 - Implement Notification system * Basic functionality of the Notification manager. Task #12 - Implement Notification system * Formatting. * Use right notification type. * Add item ID. * Use right split. * Update VMMessages_es.properties (POEditor.com) * Implemented translation interface. Task #38 - Provide interface to add translations from possible plug ins. * Add versioning to the menu. * Move classes that are not API classes to a different package. * Change hierarchy. * Move out of API folder. * Remove unused classes. * Use correct file package. * Replace add on for Vaadin provided one. * Add archieved field to notifications. * WIP Task #12 - Implement Notification system * Add sorting capabilities to notification grid. Task #12 - Implement Notification system * Update VMMessages_es.properties (POEditor.com) * Address Javadoc warnings. * Apply licensing. * Getting ready to release to GitHub. * Fix bug. * [maven-release-plugin] rollback the release of Validation-Manager-0.3.1 * Remove file. * Update submodule branch. * Release 0.3.1. * Add Wizards submodule. * Add missing Break. * Add missing translations. * Change version to 0.3.2-SNAPSHOT for development. * Change version to 0.3.2-SNAPSHOT for development. Task #44 - Main tab doesn't show on UI * Release Hot Fix 0.3.2. * Fix issue. Task #46 - Notifications Tab not translating when changing locale. * Change to development version. * Add mail related settings. * Implement engine and settings along with related unit tests. Task #42 - Support Sending email Task #42 - Support Sending email * Integrate with UI. Task #42 - Support Sending email * Fix NPE issue. * When running update() on the server class, it adds the initial history to the server but never persists to the database. So we update it when we are creating the record instead. Task #50 - History not correctly created if updating from EntityServer * 1) Make User versionable. 2) Add test to server class. 3) Fix multiple bugs uncovered during testing. Task #50 - History not correctly created if updating from EntityServer * Fix Cobertura issue. Task #52 - Code Coverage not working * Fix Cobertura issue. Task #52 - Code Coverage not working * Add missing test. * Revert last change that broke it. Task #52 - Code Coverage not working * Lots of unit tests and bug fixes identified during testing. * Fix javadoc errors. * Handle null passwords (i.e. user creation) * Implement adding users. Task #43 - Add user management * Implement User Management. Task #43 - Add user management * Add tests to check failed login attempts and account locking. * Fix various test failures. * Reorganize code to address possible NPE. * Fix extra comma on the toString method. * 1) Fix POM to avoid testing twice. 2) Add action for a Cobertura test run. * 1) Add a test to check all versionable classes. 2) Add missing Auditable fields in Project. * Test all fields of the Versionable entities. * Fixing test cases and bugs. * Fix auto incrementing notification ids. Task #55 - Notification not autoincrementing. * Only show the component to update roles to admin users. * Use correct Exception type. * Translate Demo screen. Task #49 - Demo tab not internationalized * WIP to fix bug. * Lower logging level for this message. * Add missing field. * Fix bug with modifier user. * Some more work to translate Demo tab after switching language. Task #49 - Demo tab not internationalized * Minor refactoring/formatting. * Fix initial value to be greater than the default entries. * Implement Issue Type portion. Task #53 - Add Admin management for configurable items * Update VMMessages_es.properties (POEditor.com) * Update before saving just in case. * Implement Requirement Type and Issue Resolution portions. Task #53 - Add Admin management for configurable items * Update version preparing for release. * Address Codacy review observations. --- DB/Validation Master.mwb | Bin 194165 -> 193340 bytes DB/Validation Master.mwb.bak | Bin 194164 -> 193325 bytes VM-Core/nbactions.xml | 37 + VM-Core/pom.xml | 80 +- .../manager/core/ContentProvider.java | 79 +- .../manager/core/DataBaseManager.java | 1268 +++++------ .../validation/manager/core/DemoBuilder.java | 502 ++-- .../validation/manager/core/EntityServer.java | 88 +- .../manager/core/ImportException.java | 24 - .../manager/core/ImporterInterface.java | 74 +- .../manager/core/VMIdGenerator.java | 64 - .../validation/manager/core/VaadinUtils.java | 320 +-- .../core/adapter/TimestampAdapter.java | 45 - .../email/IEmailManager.java} | 45 +- .../InternationalizationProvider.java | 62 +- .../manager/core/db/AssigmentType.java | 256 +-- .../manager/core/db/AssignmentStatus.java | 262 +-- .../manager/core/db/Attachment.java | 314 +-- .../manager/core/db/AttachmentType.java | 241 +- .../validation/manager/core/db/Baseline.java | 346 +-- .../com/validation/manager/core/db/Cause.java | 274 +-- .../manager/core/db/CorrectiveAction.java | 268 +-- .../manager/core/db/ExecutionResult.java | 237 +- .../manager/core/db/ExecutionStep.java | 724 +++--- .../manager/core/db/FailureMode.java | 274 +-- .../com/validation/manager/core/db/Fmea.java | 338 +-- .../validation/manager/core/db/Hazard.java | 276 +-- .../validation/manager/core/db/History.java | 583 ++--- .../manager/core/db/HistoryField.java | 286 +-- .../manager/core/db/Investigation.java | 254 +-- .../com/validation/manager/core/db/Issue.java | 346 +-- .../manager/core/db/IssueResolution.java | 242 +- .../validation/manager/core/db/IssueType.java | 265 ++- .../manager/core/db/Notification.java | 358 +-- .../manager/core/db/NotificationPK.java | 169 +- .../validation/manager/core/db/Project.java | 379 ++-- .../manager/core/db/Requirement.java | 526 ++--- .../manager/core/db/RequirementSpec.java | 384 ++-- .../manager/core/db/RequirementSpecNode.java | 414 ++-- .../core/db/RequirementSpecNodePK.java | 244 +- .../manager/core/db/RequirementSpecPK.java | 204 +- .../manager/core/db/RequirementStatus.java | 230 +- .../manager/core/db/RequirementType.java | 302 +-- .../manager/core/db/RiskCategory.java | 314 +-- .../manager/core/db/RiskControlPK.java | 168 +- .../manager/core/db/RiskControlType.java | 262 +-- .../manager/core/db/RiskItemPK.java | 166 +- .../com/validation/manager/core/db/Role.java | 364 +-- .../validation/manager/core/db/RootCause.java | 300 +-- .../manager/core/db/RootCausePK.java | 170 +- .../manager/core/db/RootCauseType.java | 274 +-- .../validation/manager/core/db/SpecLevel.java | 264 +-- .../com/validation/manager/core/db/Step.java | 392 ++-- .../validation/manager/core/db/StepPK.java | 168 +- .../validation/manager/core/db/TestCase.java | 420 ++-- .../manager/core/db/TestCaseExecution.java | 284 +-- .../validation/manager/core/db/TestPlan.java | 418 ++-- .../manager/core/db/TestPlanPK.java | 170 +- .../manager/core/db/TestProject.java | 336 +-- .../manager/core/db/UserAssigmentPK.java | 246 +- .../validation/manager/core/db/UserRight.java | 252 +-- .../manager/core/db/UserStatus.java | 258 +-- .../validation/manager/core/db/VmSetting.java | 352 +-- .../validation/manager/core/db/VmUser.java | 848 +++---- .../AssigmentTypeJpaController.java | 412 ++-- .../AssignmentStatusJpaController.java | 412 ++-- .../controller/AttachmentJpaController.java | 496 ++-- .../AttachmentTypeJpaController.java | 426 ++-- .../db/controller/BaselineJpaController.java | 424 ++-- .../db/controller/CauseJpaController.java | 366 +-- .../CorrectiveActionJpaController.java | 492 ++-- .../ExecutionResultJpaController.java | 386 ++-- .../ExecutionStepHasIssueJpaController.java | 524 ++--- .../ExecutionStepJpaController.java | 1200 +++++----- .../controller/FailureModeJpaController.java | 366 +-- .../db/controller/FieldTypeJpaController.java | 412 ++-- .../core/db/controller/FmeaJpaController.java | 646 +++--- .../db/controller/HazardJpaController.java | 366 +-- .../db/controller/HistoryJpaController.java | 892 ++++---- .../InvestigationJpaController.java | 520 ++--- .../db/controller/IssueJpaController.java | 554 ++--- .../IssueResolutionJpaController.java | 412 ++-- .../db/controller/IssueTypeJpaController.java | 412 ++-- .../NotificationTypeJpaController.java | 412 ++-- .../db/controller/ProjectJpaController.java | 756 +++---- .../controller/RequirementJpaController.java | 920 ++++---- .../RequirementSpecJpaController.java | 666 +++--- .../RequirementSpecNodeJpaController.java | 658 +++--- .../RequirementStatusJpaController.java | 412 ++-- .../RequirementTypeJpaController.java | 412 ++-- .../controller/ReviewResultJpaController.java | 386 ++-- .../controller/RiskCategoryJpaController.java | 492 ++-- .../controller/RiskControlJpaController.java | 762 +++---- .../RiskControlTypeJpaController.java | 412 ++-- .../db/controller/RiskItemJpaController.java | 894 ++++---- .../core/db/controller/RoleJpaController.java | 788 +++---- .../db/controller/RootCauseJpaController.java | 576 ++--- .../RootCauseTypeJpaController.java | 412 ++-- .../db/controller/SpecLevelJpaController.java | 412 ++-- .../core/db/controller/StepJpaController.java | 684 +++--- .../TestCaseExecutionJpaController.java | 412 ++-- .../db/controller/TestCaseJpaController.java | 600 ++--- .../db/controller/TestPlanJpaController.java | 730 +++--- .../controller/TestProjectJpaController.java | 600 ++--- .../db/controller/UserRightJpaController.java | 366 +-- .../controller/UserStatusJpaController.java | 412 ++-- .../db/controller/VmSettingJpaController.java | 412 ++-- .../db/controller/VmUserJpaController.java | 2011 +++++++++-------- .../manager/core/history/Login.java | 57 - .../manager/core/history/Versionable.java | 788 ++++--- .../core/server/core/AttachmentServer.java | 246 +- .../server/core/AttachmentTypeServer.java | 143 +- .../server/core/ExecutionResultServer.java | 153 +- .../core/server/core/ExecutionStepServer.java | 342 +-- .../core/server/core/FieldTypeServer.java | 124 +- .../core/server/core/HistoryServer.java | 197 +- .../core/server/core/IssueTypeServer.java | 147 +- .../core/server/core/NotificationServer.java | 158 +- .../core/server/core/ProjectServer.java | 284 ++- .../server/core/RequirementStatusServer.java | 130 +- .../server/core/RequirementTypeServer.java | 148 +- .../core/server/core/ReviewResultServer.java | 143 +- .../core/server/core/RiskControlServer.java | 191 +- .../manager/core/server/core/RoleServer.java | 156 +- .../server/core/TestCaseExecutionServer.java | 424 ++-- .../core/server/core/TestCaseServer.java | 210 +- .../core/server/core/TestPlanServer.java | 265 +-- .../core/server/core/TestProjectServer.java | 188 +- .../server/core/UserTestPlanRoleServer.java | 164 +- .../core/UserTestProjectRoleServer.java | 195 +- .../core/server/core/VMUserServer.java | 1002 ++++---- .../manager/core/server/fmea/CauseServer.java | 136 +- .../manager/core/spi/email/EmailManager.java | 94 + .../DefaultInternationalizationProvider.java | 125 +- .../com/validation/manager/core/tool/MD5.java | 88 +- .../manager/resources/VMMessages.properties | 28 +- .../resources/VMMessages_es.properties | 28 +- .../resources/VMMessages_fr_FR.properties | 5 +- .../resources/VMMessages_zh_CN.properties | 5 +- .../db/migration/V1_4__New_Setings.sql | 14 + .../core/api/email/IEmailManagerTest.java | 79 + .../InternationalizationProviderTest.java | 65 + .../manager/core/db/ProjectTest.java | 225 +- .../core/db/RequirementHierarchyTest.java | 351 +-- .../validation/manager/core/db/UserTest.java | 109 +- .../manager/core/history/VersionableTest.java | 289 +++ .../server/core/AttachmentTypeServerTest.java | 52 + .../core/ExecutionResultServerTest.java | 63 + .../core/server/core/IssueTypeServerTest.java | 52 + .../server/core/NotificationServerTest.java | 108 +- .../core/server/core/ProjectServerTest.java | 247 +- .../server/core/RequirementServerTest.java | 699 +++--- .../core/RequirementStatusServerTest.java} | 58 +- .../core/RequirementTypeServerTest.java | 52 + .../server/core/ReviewResultServerTest.java | 51 + .../core/server/core/RoleServerTest.java | 50 + .../core/UserTestProjectRoleServerTest.java | 69 + .../core/server/core/VMUserServerTest.java | 264 +++ .../core/server/core/VersionListenerIT.java | 82 - .../manager/core/tool/ToolTest.java | 100 + .../table/extractor/TableExtractorTest.java | 165 +- .../core/tool/table/extractor/Tables.xlsm | Bin 0 -> 8873 bytes .../manager/test/AbstractVMTestCase.java | 394 ++-- .../validation/manager/test/TestHelper.java | 419 ++-- Validation-Manager-Web/pom.xml | 14 +- .../validation/manager/web/LoginDialog.java | 328 +-- .../manager/web/ValidationManagerUI.java | 14 +- .../web/admin/AdminScreenProvider.java | 712 ++++-- .../ByteToStringConverter.java | 102 +- .../component/IssueResolutionComponent.java | 127 ++ .../web/component/IssueTypeComponent.java | 124 + .../component/RequirementTypeComponent.java | 131 ++ .../web/component/TranslationConverter.java | 55 + .../{ => component}/TreeTableCheckBox.java | 174 +- .../manager/web/component/UserComponent.java | 302 +++ .../UserPasswordConverter.java | 90 +- .../web/component/UserStatusConverter.java | 67 + .../UserToStringConverter.java | 76 +- .../web/{provider => demo}/DemoProvider.java | 179 +- .../web/execution/ExecutionWizardStep.java | 1490 ++++++------ .../web/notification/NotificationManager.java | 96 +- .../NotificationScreenProvider.java | 29 +- .../manager/web/profile/ProfileProvider.java | 230 +- .../manager/web/tester/ExecutionScreen.java | 724 +++--- .../web/wizard/assign/AssignUserStep.java | 294 +-- .../manager/web/wizard/plan/DetailStep.java | 250 +- .../web/wizard/plan/SelectTestCasesStep.java | 390 ++-- pom.xml | 20 +- 188 files changed, 31050 insertions(+), 28814 deletions(-) delete mode 100644 VM-Core/src/main/java/com/validation/manager/core/ImportException.java delete mode 100755 VM-Core/src/main/java/com/validation/manager/core/VMIdGenerator.java delete mode 100644 VM-Core/src/main/java/com/validation/manager/core/adapter/TimestampAdapter.java rename VM-Core/src/main/java/com/validation/manager/core/{tool/step/importer/StepImportException.java => api/email/IEmailManager.java} (55%) delete mode 100644 VM-Core/src/main/java/com/validation/manager/core/history/Login.java create mode 100644 VM-Core/src/main/java/com/validation/manager/core/spi/email/EmailManager.java create mode 100644 VM-Core/src/main/resources/db/migration/V1_4__New_Setings.sql create mode 100644 VM-Core/src/test/java/com/validation/manager/core/api/email/IEmailManagerTest.java create mode 100644 VM-Core/src/test/java/com/validation/manager/core/api/internationalization/InternationalizationProviderTest.java create mode 100644 VM-Core/src/test/java/com/validation/manager/core/history/VersionableTest.java create mode 100644 VM-Core/src/test/java/com/validation/manager/core/server/core/AttachmentTypeServerTest.java create mode 100644 VM-Core/src/test/java/com/validation/manager/core/server/core/ExecutionResultServerTest.java create mode 100644 VM-Core/src/test/java/com/validation/manager/core/server/core/IssueTypeServerTest.java rename VM-Core/src/{main/java/com/validation/manager/core/tool/Timer.java => test/java/com/validation/manager/core/server/core/RequirementStatusServerTest.java} (50%) create mode 100644 VM-Core/src/test/java/com/validation/manager/core/server/core/RequirementTypeServerTest.java create mode 100644 VM-Core/src/test/java/com/validation/manager/core/server/core/ReviewResultServerTest.java create mode 100644 VM-Core/src/test/java/com/validation/manager/core/server/core/RoleServerTest.java create mode 100644 VM-Core/src/test/java/com/validation/manager/core/server/core/UserTestProjectRoleServerTest.java create mode 100644 VM-Core/src/test/java/com/validation/manager/core/server/core/VMUserServerTest.java delete mode 100644 VM-Core/src/test/java/com/validation/manager/core/server/core/VersionListenerIT.java create mode 100644 VM-Core/src/test/java/com/validation/manager/core/tool/ToolTest.java create mode 100644 VM-Core/src/test/java/com/validation/manager/core/tool/table/extractor/Tables.xlsm rename Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/{ => component}/ByteToStringConverter.java (93%) create mode 100644 Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/IssueResolutionComponent.java create mode 100644 Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/IssueTypeComponent.java create mode 100644 Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/RequirementTypeComponent.java create mode 100644 Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/TranslationConverter.java rename Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/{ => component}/TreeTableCheckBox.java (95%) create mode 100644 Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserComponent.java rename Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/{profile => component}/UserPasswordConverter.java (83%) create mode 100644 Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserStatusConverter.java rename Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/{ => component}/UserToStringConverter.java (92%) rename Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/{provider => demo}/DemoProvider.java (79%) diff --git a/DB/Validation Master.mwb b/DB/Validation Master.mwb index 333dd93e5fab4c0ca5ec86d2c0580fc394163e06..739c74ad7ff0e8e708da414ef7c7d5793a26c8f9 100644 GIT binary patch literal 193340 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

j1!h(AFw!%!@)?i;VPtpaXYYUvRoR_6h7 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 z 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

K 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

+dMrkWhEI^Pvew(KPr#D~-MYMwwG3$4p z>f_!#NBv5>xQB%u=&2tsj(z`kWoF`8hBP@e2~V k-JRisfuRm=wlHaCKU-HPjI6ekhr6|#t-CG6!JF{^0M&k`DF6Tf diff --git a/DB/Validation Master.mwb.bak b/DB/Validation Master.mwb.bak index 53d7d31ba311c742582c64feeb1cc560c833db94..fbe3498399e145ab53c43e22691cb51959b293a2 100644 GIT binary patch literal 193325 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 XncCX|#@x0r2VNpGtU15;z+>G literal 194164 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 z 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 R+0(gYrGe*hkZsFVNz diff --git a/VM-Core/nbactions.xml b/VM-Core/nbactions.xml index 98e195af..d27d733c 100644 --- a/VM-Core/nbactions.xml +++ b/VM-Core/nbactions.xml @@ -43,4 +43,41 @@ java + + test + + * + + + test + + + true + + + + test.single + + * + + + test-compile + surefire:test + + + ${packageClassName} + true + + + + CUSTOM-Coverage Report + Coverage Report + + verify + + + true + false + + diff --git a/VM-Core/pom.xml b/VM-Core/pom.xml index ee661c95..04419742 100644 --- a/VM-Core/pom.xml +++ b/VM-Core/pom.xml @@ -4,7 +4,7 @@ net.sourceforge.javydreamercsw Validation-Manager - 0.3.2 + 0.3.3 VM-Core @@ -141,6 +141,25 @@ jacoco-maven-plugin test + + + javax.mail + javax.mail-api + 1.5.6 + + + com.sun.mail + javax.mail + 1.5.6 + + + + de.saly + javamail-mock2-fullmock + 0.5-beta4 + test + + @@ -158,52 +177,53 @@ + + maven-surefire-plugin + + ${cobertura.test} + + + + unit-test + test + + test + + + ${maven.test.skip} + ${argLine} + + **/*IT.java + + + + + org.jacoco jacoco-maven-plugin 0.7.9 + + ${skipTests} + file + true + - - pre-unit-test + jacoco-initialize prepare-agent - - - jacocoArgLine - - - post-unit-test - test + jacoco-site + verify report - - org.apache.maven.plugins - maven-surefire-report-plugin - 2.20 - - - - ${jacocoArgLine} - - diff --git a/VM-Core/src/main/java/com/validation/manager/core/ContentProvider.java b/VM-Core/src/main/java/com/validation/manager/core/ContentProvider.java index e3a5d1e2..d3d2dae9 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/ContentProvider.java +++ b/VM-Core/src/main/java/com/validation/manager/core/ContentProvider.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,39 +13,44 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core; - -import com.vaadin.ui.Component; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public interface ContentProvider { - - /** - * Return the component caption. This will be attempted to be translated. - * - * @return component caption - */ - String getComponentCaption(); - - /** - * The Content of the provider - * - * @return content. - */ - Component getContent(); - - /** - * This is the unique id of the provider - * - * @return unique id for the provider. - */ - String getId(); - - /** - * Refresh the contents. - */ - void update(); -} +package com.validation.manager.core; + +import com.vaadin.ui.Component; +import com.validation.manager.core.api.internationalization.InternationalizationProvider; +import org.openide.util.Lookup; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public interface ContentProvider { + + static final InternationalizationProvider TRANSLATOR + = Lookup.getDefault().lookup(InternationalizationProvider.class); + + /** + * Return the component caption. This will be attempted to be translated. + * + * @return component caption + */ + String getComponentCaption(); + + /** + * The Content of the provider + * + * @return content. + */ + Component getContent(); + + /** + * This is the unique id of the provider + * + * @return unique id for the provider. + */ + String getId(); + + /** + * Refresh the contents. + */ + void update(); +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/DataBaseManager.java b/VM-Core/src/main/java/com/validation/manager/core/DataBaseManager.java index e1ac70bb..fdd87224 100755 --- a/VM-Core/src/main/java/com/validation/manager/core/DataBaseManager.java +++ b/VM-Core/src/main/java/com/validation/manager/core/DataBaseManager.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,636 +13,636 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core; - -import com.googlecode.flyway.core.Flyway; -import com.googlecode.flyway.core.api.FlywayException; -import com.googlecode.flyway.core.api.MigrationInfo; -import com.googlecode.flyway.core.api.MigrationState; -import com.validation.manager.core.db.controller.VmIdJpaController; -import com.validation.manager.core.server.core.VMIdServer; -import com.validation.manager.core.server.core.VMSettingServer; -import static java.lang.Class.forName; -import static java.lang.Integer.parseInt; -import static java.lang.Long.valueOf; -import static java.lang.Thread.sleep; -import java.lang.reflect.Field; -import java.sql.Connection; -import java.sql.PreparedStatement; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; -import java.util.StringTokenizer; -import java.util.concurrent.TimeUnit; -import java.util.logging.Level; -import java.util.logging.Logger; -import static java.util.logging.Logger.getLogger; -import javax.naming.InitialContext; -import javax.naming.NamingException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; -import javax.persistence.EntityTransaction; -import static javax.persistence.Persistence.createEntityManagerFactory; -import javax.persistence.Query; -import javax.persistence.TableGenerator; -import javax.sql.DataSource; -import org.h2.jdbcx.JdbcDataSource; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class DataBaseManager { - - private static EntityManagerFactory emf; - private static Map properties; - //Default. Can be overwritten using setPersistenceUnitName(String aPU) - private static String PU = "VMPU"; - private static EntityManager em; - private static boolean dbError = false; - private static final Logger LOG - = getLogger(DataBaseManager.class.getSimpleName()); - private static DBState state = DBState.START_UP; - private static boolean locked = false; - private static boolean usingContext; - private static boolean demo; - private static Long demoResetPeriod; - private static DataBaseManager instance; - private static boolean versioning_enabled = true; - - /** - * @return the versioning enabled - */ - public static boolean isVersioningEnabled() { - return versioning_enabled; - } - - /** - * @param aVersioning_enabled the versioning_enabled to set - */ - public static void setVersioningEnabled(boolean aVersioning_enabled) { - versioning_enabled = aVersioning_enabled; - } - - /** - * @return the demoResetPeriod - */ - public static Long getDemoResetPeriod() { - return demoResetPeriod; - } - - private DataBaseManager() { - } - - public static DataBaseManager get() throws Exception { - if (instance == null) { - instance = new DataBaseManager(); - } - return instance; - } - - @SuppressWarnings("unchecked") - private static void processFields(Field[] fields) { - try { - for (Field field : fields) { - if (field.isAnnotationPresent(TableGenerator.class)) { - field.setAccessible(true); - TableGenerator annotation = field.getAnnotation(TableGenerator.class); - field.setAccessible(false); - Map parameters = new HashMap<>(); - String tableName = annotation.pkColumnValue(); - parameters.put("tableName", tableName); - if (namedQuery("VmId.findByTableName", parameters, false).isEmpty()) { - LOG.log(Level.FINE, "Adding: {0}: {1}", - new Object[]{tableName, annotation.initialValue() - 1}); - VMIdServer temp = new VMIdServer(tableName, annotation.initialValue() - 1); - temp.write2DB(); - LOG.log(Level.FINE, "Added: {0}: {1}", - new Object[]{tableName, annotation.initialValue() - 1}); - } - } - } - } - catch (VMException ex1) { - LOG.log(Level.SEVERE, null, ex1); - } - finally { - if (LOG.isLoggable(Level.CONFIG)) { - VmIdJpaController controller = new VmIdJpaController( - getEntityManagerFactory()); - controller.findVmIdEntities().stream().forEach((next) -> { - LOG.log(Level.CONFIG, "{0}, {1}, {2}", new Object[]{next.getId(), - next.getTableName(), next.getLastId()}); - }); - } - } - } - - private static void generateIDs() { - if (!dbError) { - LOG.log(Level.FINE, - "Creating ids to work around eclipse issue " - + "(https://bugs.eclipse.org/bugs/show_bug.cgi?id=366852)..."); - getEntityManager().getMetamodel().getEmbeddables().forEach((et) -> { - processFields(et.getJavaType().getDeclaredFields()); - }); - getEntityManager().getMetamodel().getEntities().forEach((et) -> { - processFields(et.getBindableJavaType().getDeclaredFields()); - }); - LOG.log(Level.FINE, "Done!"); - } - } - - /** - * @return the properties - */ - public static Map getProperties() { - return properties; - } - - /** - * Get the current persistence unit name - * - * @return current persistence unit name - */ - public static String getPersistenceUnitName() { - return PU; - } - - /** - * @param aPU the PU to set - */ - public static void setPersistenceUnitName(String aPU) { - PU = aPU; - LOG.log(Level.FINE, "Changed persistence unit name to: {0}", PU); - //Set it to null so it's recreated with new Persistence Unit next time is requested. - emf = null; - em = null; - try { - reload(); - } - catch (VMException ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - - public static void setEntityManagerFactory(EntityManagerFactory newEMF) { - emf = newEMF; - } - - /** - * @return the emf - */ - public static EntityManagerFactory getEntityManagerFactory() { - if (emf == null && !dbError) { - try { - InitialContext ctx = new InitialContext(); - //Use the context defined Database connection - PU = (String) ctx.lookup("java:comp/env/validation-manager/JNDIDB"); - try { - demo = (Boolean) ctx.lookup("java:comp/env/validation-manager/demo"); - } - catch (NamingException e) { - LOG.log(Level.SEVERE, null, e); - demo = false; - } - if (isDemo()) { - try { - demoResetPeriod = (Long) ctx - .lookup("java:comp/env/validation-manager/demo-period"); - } - catch (NamingException e) { - LOG.log(Level.SEVERE, null, e); - demoResetPeriod = valueOf(0); - } - if (getDemoResetPeriod() > 0) { - Long millis = getDemoResetPeriod(); - String format = String.format("%02d min, %02d sec", - TimeUnit.MILLISECONDS.toMinutes(millis), - TimeUnit.MILLISECONDS.toSeconds(millis) - - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)) - ); - LOG.log(Level.WARNING, - "Instance configured as demo, database will reset" - + " each {0}", format); - } - } - final String JNDIDB = (String) ctx.lookup("java:comp/env/validation-manager/JNDIDB"); - emf = createEntityManagerFactory(JNDIDB); - LOG.log(Level.FINE, "Using context defined database connection: {0}", JNDIDB); - usingContext = true; - } - catch (NamingException e) { - LOG.log(Level.FINE, null, e); - if (!usingContext) { - LOG.log(Level.WARNING, - "Manually specified connection parameters. " - + "Using pre-defined persistence unit: {0}", PU); - emf = createEntityManagerFactory(PU); - } else { - LOG.log(Level.SEVERE, - "Context doesn't exist. Check your configuration.", e); - dbError = true; - } - } - } - return emf; - } - - /** - * @return the demo - */ - public static boolean isDemo() { - return demo; - } - - public static EntityManager getEntityManager() { - if (em == null) { - em = getEntityManagerFactory().createEntityManager(); - LOG.log(Level.FINE, - "Creating EntityManager from: {0}", PU); - properties = em.getProperties(); - } - return em; - } - - public static List createdQuery(String query) { - return createdQuery(query, null); - } - - @SuppressWarnings("unchecked") - public static List createdQuery(String query, Map parameters) { - Query q = getEntityManager().createQuery(query); - if (parameters != null) { - Iterator> entries = parameters.entrySet().iterator(); - while (entries.hasNext()) { - Entry e = entries.next(); - q.setParameter(e.getKey(), e.getValue()); - } - } - return q.getResultList(); - } - - /** - * Named query that will modify the database - * - * @param query query to execute - */ - public static void namedUpdateQuery(String query) { - namedQuery(query, null, true); - } - - public static List nativeQuery(String query) { - List resultList - = getEntityManager().createNativeQuery(query).getResultList(); - return resultList; - } - - public static List createdQuery(String query, T result) { - List resultList - = getEntityManager().createQuery(query).getResultList(); - return resultList; - } - - public static void nativeUpdateQuery(String query) { - getEntityManager().createNativeQuery(query).executeUpdate(); - } - - /** - * Named query (not for updates) - * - * @param query query to execute - * @return query result - */ - public static List namedQuery(String query) { - return namedQuery(query, null, false); - } - - /** - * Named query that will modify the database - * - * @param query query to execute - * @param parameters query parameters - */ - public static void namedUpdateQuery(String query, Map parameters) { - namedQuery(query, parameters, true); - } - - /** - * Named query (not for updates) - * - * @param query query to execute - * @param parameters query parameters - * @return query result - */ - public static List namedQuery(String query, - Map parameters) { - return namedQuery(query, parameters, false); - } - - @SuppressWarnings("unchecked") - private static List namedQuery(String query, - Map parameters, boolean change) { - EntityTransaction transaction = getEntityManager().getTransaction(); - if (change) { - transaction.begin(); - } - Query q = getEntityManager().createNamedQuery(query); - if (parameters != null) { - Iterator> entries - = parameters.entrySet().iterator(); - while (entries.hasNext()) { - Entry e = entries.next(); - q.setParameter(e.getKey(), e.getValue()); - } - } - if (change) { - transaction.commit(); - } - return q.getResultList(); - } - - public static void close() { - getEntityManager().close(); - getEntityManagerFactory().close(); - emf = null; - em = null; - } - - public static EntityTransaction getTransaction() { - return getEntityManager().getTransaction(); - } - - public static void reload() throws VMException { - reload(false); - } - - public static void reload(boolean close) throws VMException { - if (close) { - close(); - } - updateDBState(); - getEntityManager(); - generateIDs(); - } - - public static void updateDBState() { - DataSource ds = null; - Connection conn = null; - PreparedStatement stmt = null; - ResultSet rs = null; - try { - ds = (javax.sql.DataSource) new InitialContext().lookup("java:comp/env/jdbc/VMDB"); - conn = ds.getConnection(); - } - catch (NamingException ne) { - LOG.log(Level.FINE, null, ne); - if (emf == null) { - try { - //It might be the tests, use an H2 Database - ds = new JdbcDataSource(); - ((JdbcDataSource) ds).setPassword(""); - ((JdbcDataSource) ds).setUser("vm_user"); - ((JdbcDataSource) ds).setURL( - "jdbc:h2:file:./target/data/test/validation-manager-test;AUTO_SERVER=TRUE"); - //Load the H2 driver - forName("org.h2.Driver"); - conn = ds.getConnection(); - } - catch (ClassNotFoundException | SQLException ex) { - LOG.log(Level.SEVERE, null, ex); - } - } else { - EntityTransaction transaction = getEntityManager().getTransaction(); - transaction.begin(); - conn = getEntityManager().unwrap(java.sql.Connection.class); - transaction.commit(); - } - } - catch (SQLException ex) { - LOG.log(Level.SEVERE, null, ex); - } - if (conn != null) { - try { - stmt = conn.prepareStatement("select * from vm_setting"); - rs = stmt.executeQuery(); - if (!rs.next()) { - //Tables there but empty? Not safe to proceed - setState(DBState.NEED_MANUAL_UPDATE); - } - } - catch (SQLException ex) { - LOG.log(Level.FINE, null, ex); - //Need INIT, probably nothing there - setState(DBState.NEED_INIT); - //Create the database - getEntityManager(); - } - finally { - try { - conn.close(); - } - catch (SQLException ex) { - LOG.log(Level.SEVERE, null, ex); - } - try { - if (stmt != null) { - stmt.close(); - } - } - catch (SQLException ex) { - LOG.log(Level.SEVERE, null, ex); - } - try { - if (rs != null) { - rs.close(); - } - } - catch (SQLException ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - } - if (ds != null) { - //Initialize flyway - initializeFlyway(ds); - updateDatabase(ds); - } else { - state = DBState.ERROR; - } - - if (state != DBState.VALID) { - waitForDB(); - } - } - - private static void updateDatabase(DataSource dataSource) { - Flyway flyway = new Flyway(); - try { - flyway.setDataSource(dataSource); - flyway.setLocations("db.migration"); - LOG.fine("Starting migration..."); - flyway.migrate(); - LOG.fine("Done!"); - } - catch (FlywayException fe) { - LOG.log(Level.SEVERE, "Unable to migrate data", fe); - setState(DBState.ERROR); - } - try { - LOG.fine("Validating migration..."); - flyway.validate(); - LOG.fine("Done!"); - setState(flyway.info().current().getState() - == MigrationState.SUCCESS ? DBState.VALID : DBState.ERROR); - } - catch (FlywayException fe) { - LOG.log(Level.SEVERE, "Unable to validate", fe); - setState(DBState.ERROR); - } - } - - protected static void setState(DBState newState) { - state = newState; - } - - public static void waitForDB() { - while (getState() != DBState.VALID - && getState() != DBState.UPDATED - && getState() != DBState.ERROR) { - LOG.log(Level.FINE, - "Waiting for DB initialization. Current state: {0}", - (getState() != null ? getState().name() : null)); - try { - sleep(100); - } - catch (InterruptedException ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - LOG.log(Level.FINE, "DB ready, resuming..."); - } - - /** - * @return the state - */ - public static DBState getState() { - return state; - } - - /** - * @param lock the lock to set - */ - public static void setLocked(boolean lock) { - LOG.log(Level.WARNING, "{0} the database.", - (lock ? "Locking" : "Unlocking")); - locked = lock; - } - - public static String getVersion() { - return getVersionNumber() - + ((VMSettingServer.getSetting("version.postfix") - .getStringVal().isEmpty() - ? "" : " " - + VMSettingServer.getSetting("version.postfix") - .getStringVal())); - } - - public static String getVersionNumber() { - StringBuilder version = new StringBuilder(); - version.append(VMSettingServer.getSetting("version.high").getIntVal()); - version.append("."); - version.append(VMSettingServer.getSetting("version.mid").getIntVal()); - version.append("."); - version.append(VMSettingServer.getSetting("version.low").getIntVal()); - return version.toString(); - } - - /** - * Compare two number strings. For example: 2.1.0 == 2.01.00 - * - * @param first first string to compare - * @param second second string to compare - * @return true if same, false otherwise - */ - public static boolean compareNumberStrings(String first, String second) { - return compareNumberStrings(first, second, "."); - } - - /** - * Compare two number strings. For example: 2.1.0 == 2.01.00 - * - * @param first first string to compare - * @param second second string to compare - * @param separator separator of fields (i.e. for 2.1.0 is '.') - * @return true if same, false otherwise - */ - public static boolean compareNumberStrings(String first, String second, - String separator) { - boolean result = true; - StringTokenizer firstST = new StringTokenizer(first, separator); - StringTokenizer secondST = new StringTokenizer(second, separator); - if (firstST.countTokens() != secondST.countTokens()) { - //Different amount of fields, not equal. (i.e. 2.1 and 2.1.1 - result = false; - } else { - try { - while (firstST.hasMoreTokens()) { - int firstInt = parseInt(firstST.nextToken()); - int secondInt = parseInt(secondST.nextToken()); - //Both numbers let's continue - if (firstInt != secondInt) { - result = false; - break; - } - } - //Everything the same - } - catch (java.lang.NumberFormatException e) { - LOG.log(Level.WARNING, null, e); - //Is not a number - result = false; - } - } - return result; - } - - /** - * @return the locked - */ - public static boolean isLocked() { - return locked; - } - - private static void initializeFlyway(DataSource dataSource) { - assert dataSource != null; - setState(DBState.START_UP); - Flyway flyway = new Flyway(); - flyway.setDataSource(dataSource); - MigrationInfo status = flyway.info().current(); - if (status == null) { - setState(DBState.NEED_INIT); - LOG.fine("Initialize the metadata..."); - try { - flyway.init(); - LOG.fine("Done!"); - } - catch (FlywayException fe) { - LOG.log(Level.SEVERE, "Unable to initialize database", fe); - setState(DBState.ERROR); - } - } else { - LOG.fine("Database has Flyway metadata already..."); - displayDBStatus(status); - } - } - - private static void displayDBStatus(MigrationInfo status) { - LOG.log(Level.FINE, "Description: {0}\nState: {1}\nVersion: {2}", - new Object[]{status.getDescription(), status.getState(), status.getVersion()}); - } -} +package com.validation.manager.core; + +import com.googlecode.flyway.core.Flyway; +import com.googlecode.flyway.core.api.FlywayException; +import com.googlecode.flyway.core.api.MigrationInfo; +import com.googlecode.flyway.core.api.MigrationState; +import com.validation.manager.core.db.controller.VmIdJpaController; +import com.validation.manager.core.server.core.VMIdServer; +import com.validation.manager.core.server.core.VMSettingServer; +import static java.lang.Class.forName; +import static java.lang.Integer.parseInt; +import static java.lang.Long.valueOf; +import static java.lang.Thread.sleep; +import java.lang.reflect.Field; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.StringTokenizer; +import java.util.concurrent.TimeUnit; +import java.util.logging.Level; +import java.util.logging.Logger; +import static java.util.logging.Logger.getLogger; +import javax.naming.InitialContext; +import javax.naming.NamingException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.EntityTransaction; +import static javax.persistence.Persistence.createEntityManagerFactory; +import javax.persistence.Query; +import javax.persistence.TableGenerator; +import javax.sql.DataSource; +import org.h2.jdbcx.JdbcDataSource; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class DataBaseManager { + + private static EntityManagerFactory emf; + private static Map properties; + //Default. Can be overwritten using setPersistenceUnitName(String aPU) + private static String PU = "VMPU"; + private static EntityManager em; + private static boolean dbError = false; + private static final Logger LOG + = getLogger(DataBaseManager.class.getSimpleName()); + private static DBState state = DBState.START_UP; + private static boolean locked = false; + private static boolean usingContext; + private static boolean demo; + private static Long demoResetPeriod; + private static DataBaseManager instance; + private static boolean versioning_enabled = true; + + /** + * @return the versioning enabled + */ + public static boolean isVersioningEnabled() { + return versioning_enabled; + } + + /** + * @param aVersioning_enabled the versioning_enabled to set + */ + public static void setVersioningEnabled(boolean aVersioning_enabled) { + versioning_enabled = aVersioning_enabled; + } + + /** + * @return the demoResetPeriod + */ + public static Long getDemoResetPeriod() { + return demoResetPeriod; + } + + private DataBaseManager() { + } + + public static DataBaseManager get() throws Exception { + if (instance == null) { + instance = new DataBaseManager(); + } + return instance; + } + + @SuppressWarnings("unchecked") + private static void processFields(Field[] fields) { + try { + for (Field field : fields) { + if (field.isAnnotationPresent(TableGenerator.class)) { + field.setAccessible(true); + TableGenerator annotation = field.getAnnotation(TableGenerator.class); + field.setAccessible(false); + Map parameters = new HashMap<>(); + String tableName = annotation.pkColumnValue(); + parameters.put("tableName", tableName); + if (namedQuery("VmId.findByTableName", parameters, false).isEmpty()) { + LOG.log(Level.FINE, "Adding: {0}: {1}", + new Object[]{tableName, annotation.initialValue() - 1}); + VMIdServer temp = new VMIdServer(tableName, annotation.initialValue() - 1); + temp.write2DB(); + LOG.log(Level.FINE, "Added: {0}: {1}", + new Object[]{tableName, annotation.initialValue() - 1}); + } + } + } + } + catch (VMException ex1) { + LOG.log(Level.SEVERE, null, ex1); + } + finally { + if (LOG.isLoggable(Level.CONFIG)) { + VmIdJpaController controller = new VmIdJpaController( + getEntityManagerFactory()); + controller.findVmIdEntities().stream().forEach((next) -> { + LOG.log(Level.CONFIG, "{0}, {1}, {2}", new Object[]{next.getId(), + next.getTableName(), next.getLastId()}); + }); + } + } + } + + private static void generateIDs() { + if (!dbError) { + LOG.log(Level.FINE, + "Creating ids to work around eclipse issue " + + "(https://bugs.eclipse.org/bugs/show_bug.cgi?id=366852)..."); + getEntityManager().getMetamodel().getEmbeddables().forEach((et) -> { + processFields(et.getJavaType().getDeclaredFields()); + }); + getEntityManager().getMetamodel().getEntities().forEach((et) -> { + processFields(et.getBindableJavaType().getDeclaredFields()); + }); + LOG.log(Level.FINE, "Done!"); + } + } + + /** + * @return the properties + */ + public static Map getProperties() { + return properties; + } + + /** + * Get the current persistence unit name + * + * @return current persistence unit name + */ + public static String getPersistenceUnitName() { + return PU; + } + + /** + * @param aPU the PU to set + */ + public static void setPersistenceUnitName(String aPU) { + PU = aPU; + LOG.log(Level.FINE, "Changed persistence unit name to: {0}", PU); + //Set it to null so it's recreated with new Persistence Unit next time is requested. + emf = null; + em = null; + try { + reload(); + } + catch (VMException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + + public static void setEntityManagerFactory(EntityManagerFactory newEMF) { + emf = newEMF; + } + + /** + * @return the emf + */ + public static EntityManagerFactory getEntityManagerFactory() { + if (emf == null && !dbError) { + try { + InitialContext ctx = new InitialContext(); + //Use the context defined Database connection + PU = (String) ctx.lookup("java:comp/env/validation-manager/JNDIDB"); + try { + demo = (Boolean) ctx.lookup("java:comp/env/validation-manager/demo"); + } + catch (NamingException e) { + LOG.log(Level.SEVERE, null, e); + demo = false; + } + if (isDemo()) { + try { + demoResetPeriod = (Long) ctx + .lookup("java:comp/env/validation-manager/demo-period"); + } + catch (NamingException e) { + LOG.log(Level.SEVERE, null, e); + demoResetPeriod = valueOf(0); + } + if (getDemoResetPeriod() > 0) { + Long millis = getDemoResetPeriod(); + String format = String.format("%02d min, %02d sec", + TimeUnit.MILLISECONDS.toMinutes(millis), + TimeUnit.MILLISECONDS.toSeconds(millis) + - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)) + ); + LOG.log(Level.WARNING, + "Instance configured as demo, database will reset" + + " each {0}", format); + } + } + final String JNDIDB = (String) ctx.lookup("java:comp/env/validation-manager/JNDIDB"); + emf = createEntityManagerFactory(JNDIDB); + LOG.log(Level.FINE, "Using context defined database connection: {0}", JNDIDB); + usingContext = true; + } + catch (NamingException e) { + LOG.log(Level.FINE, null, e); + if (!usingContext) { + LOG.log(Level.WARNING, + "Manually specified connection parameters. " + + "Using pre-defined persistence unit: {0}", PU); + emf = createEntityManagerFactory(PU); + } else { + LOG.log(Level.SEVERE, + "Context doesn't exist. Check your configuration.", e); + dbError = true; + } + } + } + return emf; + } + + /** + * @return the demo + */ + public static boolean isDemo() { + return demo; + } + + public static EntityManager getEntityManager() { + if (em == null) { + em = getEntityManagerFactory().createEntityManager(); + LOG.log(Level.FINE, + "Creating EntityManager from: {0}", PU); + properties = em.getProperties(); + } + return em; + } + + public static List createdQuery(String query) { + return createdQuery(query, null); + } + + @SuppressWarnings("unchecked") + public static List createdQuery(String query, Map parameters) { + Query q = getEntityManager().createQuery(query); + if (parameters != null) { + Iterator> entries = parameters.entrySet().iterator(); + while (entries.hasNext()) { + Entry e = entries.next(); + q.setParameter(e.getKey(), e.getValue()); + } + } + return q.getResultList(); + } + + /** + * Named query that will modify the database + * + * @param query query to execute + */ + public static void namedUpdateQuery(String query) { + namedQuery(query, null, true); + } + + public static List nativeQuery(String query) { + List resultList + = getEntityManager().createNativeQuery(query).getResultList(); + return resultList; + } + + public static List createdQuery(String query, T result) { + List resultList + = getEntityManager().createQuery(query).getResultList(); + return resultList; + } + + public static void nativeUpdateQuery(String query) { + getEntityManager().createNativeQuery(query).executeUpdate(); + } + + /** + * Named query (not for updates) + * + * @param query query to execute + * @return query result + */ + public static List namedQuery(String query) { + return namedQuery(query, null, false); + } + + /** + * Named query that will modify the database + * + * @param query query to execute + * @param parameters query parameters + */ + public static void namedUpdateQuery(String query, Map parameters) { + namedQuery(query, parameters, true); + } + + /** + * Named query (not for updates) + * + * @param query query to execute + * @param parameters query parameters + * @return query result + */ + public static List namedQuery(String query, + Map parameters) { + return namedQuery(query, parameters, false); + } + + @SuppressWarnings("unchecked") + private static List namedQuery(String query, + Map parameters, boolean change) { + EntityTransaction transaction = getEntityManager().getTransaction(); + if (change) { + transaction.begin(); + } + Query q = getEntityManager().createNamedQuery(query); + if (parameters != null) { + Iterator> entries + = parameters.entrySet().iterator(); + while (entries.hasNext()) { + Entry e = entries.next(); + q.setParameter(e.getKey(), e.getValue()); + } + } + if (change) { + transaction.commit(); + } + return q.getResultList(); + } + + public static void close() { + getEntityManager().close(); + getEntityManagerFactory().close(); + emf = null; + em = null; + } + + public static EntityTransaction getTransaction() { + return getEntityManager().getTransaction(); + } + + public static void reload() throws VMException { + reload(false); + } + + public static void reload(boolean close) throws VMException { + if (close) { + close(); + } + updateDBState(); + getEntityManager(); + generateIDs(); + } + + public static void updateDBState() { + DataSource ds = null; + Connection conn = null; + PreparedStatement stmt = null; + ResultSet rs = null; + try { + ds = (javax.sql.DataSource) new InitialContext().lookup("java:comp/env/jdbc/VMDB"); + conn = ds.getConnection(); + } + catch (NamingException ne) { + LOG.log(Level.FINE, null, ne); + if (emf == null) { + try { + //It might be the tests, use an H2 Database + ds = new JdbcDataSource(); + ((JdbcDataSource) ds).setPassword(""); + ((JdbcDataSource) ds).setUser("vm_user"); + ((JdbcDataSource) ds).setURL( + "jdbc:h2:file:./target/data/test/validation-manager-test;AUTO_SERVER=TRUE"); + //Load the H2 driver + forName("org.h2.Driver"); + conn = ds.getConnection(); + } + catch (ClassNotFoundException | SQLException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } else { + EntityTransaction transaction = getEntityManager().getTransaction(); + transaction.begin(); + conn = getEntityManager().unwrap(java.sql.Connection.class); + transaction.commit(); + } + } + catch (SQLException ex) { + LOG.log(Level.SEVERE, null, ex); + } + if (conn != null) { + try { + stmt = conn.prepareStatement("select * from vm_setting"); + rs = stmt.executeQuery(); + if (!rs.next()) { + //Tables there but empty? Not safe to proceed + setState(DBState.NEED_MANUAL_UPDATE); + } + } + catch (SQLException ex) { + LOG.log(Level.FINE, null, ex); + //Need INIT, probably nothing there + setState(DBState.NEED_INIT); + //Create the database + getEntityManager(); + } + finally { + try { + conn.close(); + } + catch (SQLException ex) { + LOG.log(Level.SEVERE, null, ex); + } + try { + if (stmt != null) { + stmt.close(); + } + } + catch (SQLException ex) { + LOG.log(Level.SEVERE, null, ex); + } + try { + if (rs != null) { + rs.close(); + } + } + catch (SQLException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + } + if (ds != null) { + //Initialize flyway + initializeFlyway(ds); + updateDatabase(ds); + } else { + state = DBState.ERROR; + } + + if (state != DBState.VALID) { + waitForDB(); + } + } + + private static void updateDatabase(DataSource dataSource) { + Flyway flyway = new Flyway(); + try { + flyway.setDataSource(dataSource); + flyway.setLocations("db.migration"); + LOG.fine("Starting migration..."); + flyway.migrate(); + LOG.fine("Done!"); + } + catch (FlywayException fe) { + LOG.log(Level.SEVERE, "Unable to migrate data", fe); + setState(DBState.ERROR); + } + try { + LOG.fine("Validating migration..."); + flyway.validate(); + LOG.fine("Done!"); + setState(flyway.info().current().getState() + == MigrationState.SUCCESS ? DBState.VALID : DBState.ERROR); + } + catch (FlywayException fe) { + LOG.log(Level.SEVERE, "Unable to validate", fe); + setState(DBState.ERROR); + } + } + + protected static void setState(DBState newState) { + state = newState; + } + + public static void waitForDB() { + while (getState() != DBState.VALID + && getState() != DBState.UPDATED + && getState() != DBState.ERROR) { + LOG.log(Level.FINE, + "Waiting for DB initialization. Current state: {0}", + (getState() != null ? getState().name() : null)); + try { + sleep(100); + } + catch (InterruptedException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + LOG.log(Level.FINE, "DB ready, resuming..."); + } + + /** + * @return the state + */ + public static DBState getState() { + return state; + } + + /** + * @param lock the lock to set + */ + public static void setLocked(boolean lock) { + LOG.log(Level.WARNING, "{0} the database.", + (lock ? "Locking" : "Unlocking")); + locked = lock; + } + + public static String getVersion() { + return getVersionNumber() + + ((VMSettingServer.getSetting("version.postfix") + .getStringVal().isEmpty() + ? "" : " " + + VMSettingServer.getSetting("version.postfix") + .getStringVal())); + } + + public static String getVersionNumber() { + StringBuilder version = new StringBuilder(); + version.append(VMSettingServer.getSetting("version.high").getIntVal()); + version.append("."); + version.append(VMSettingServer.getSetting("version.mid").getIntVal()); + version.append("."); + version.append(VMSettingServer.getSetting("version.low").getIntVal()); + return version.toString(); + } + + /** + * Compare two number strings. For example: 2.1.0 == 2.01.00 + * + * @param first first string to compare + * @param second second string to compare + * @return true if same, false otherwise + */ + public static boolean compareNumberStrings(String first, String second) { + return compareNumberStrings(first, second, "."); + } + + /** + * Compare two number strings. For example: 2.1.0 == 2.01.00 + * + * @param first first string to compare + * @param second second string to compare + * @param separator separator of fields (i.e. for 2.1.0 is '.') + * @return true if same, false otherwise + */ + public static boolean compareNumberStrings(String first, String second, + String separator) { + boolean result = true; + StringTokenizer firstST = new StringTokenizer(first, separator); + StringTokenizer secondST = new StringTokenizer(second, separator); + if (firstST.countTokens() != secondST.countTokens()) { + //Different amount of fields, not equal. (i.e. 2.1 and 2.1.1 + result = false; + } else { + try { + while (firstST.hasMoreTokens()) { + int firstInt = parseInt(firstST.nextToken()); + int secondInt = parseInt(secondST.nextToken()); + //Both numbers let's continue + if (firstInt != secondInt) { + result = false; + break; + } + } + //Everything the same + } + catch (java.lang.NumberFormatException e) { + LOG.log(Level.WARNING, null, e); + //Is not a number + result = false; + } + } + return result; + } + + /** + * @return the locked + */ + public static boolean isLocked() { + return locked; + } + + private static void initializeFlyway(DataSource dataSource) { + assert dataSource != null; + setState(DBState.START_UP); + Flyway flyway = new Flyway(); + flyway.setDataSource(dataSource); + MigrationInfo status = flyway.info().current(); + if (status == null) { + setState(DBState.NEED_INIT); + LOG.fine("Initialize the metadata..."); + try { + flyway.init(); + LOG.fine("Done!"); + } + catch (FlywayException fe) { + LOG.log(Level.SEVERE, "Unable to initialize database", fe); + setState(DBState.ERROR); + } + } else { + LOG.fine("Database has Flyway metadata already..."); + displayDBStatus(status); + } + } + + private static void displayDBStatus(MigrationInfo status) { + LOG.log(Level.FINE, "Description: {0}\nState: {1}\nVersion: {2}", + new Object[]{status.getDescription(), status.getState(), status.getVersion()}); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/DemoBuilder.java b/VM-Core/src/main/java/com/validation/manager/core/DemoBuilder.java index 9e561abf..107bb18d 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/DemoBuilder.java +++ b/VM-Core/src/main/java/com/validation/manager/core/DemoBuilder.java @@ -13,254 +13,254 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core; - -import com.validation.manager.core.db.Project; -import com.validation.manager.core.db.Requirement; -import com.validation.manager.core.db.Step; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.controller.ProjectJpaController; -import com.validation.manager.core.db.controller.RequirementJpaController; -import com.validation.manager.core.db.controller.TestCaseJpaController; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.server.core.ExecutionStepServer; -import com.validation.manager.core.server.core.ProjectServer; -import com.validation.manager.core.server.core.RequirementServer; -import com.validation.manager.core.server.core.RequirementSpecNodeServer; -import com.validation.manager.core.server.core.RequirementSpecServer; -import com.validation.manager.core.server.core.StepServer; -import com.validation.manager.core.server.core.TestCaseExecutionServer; -import com.validation.manager.core.server.core.TestCaseServer; -import com.validation.manager.core.server.core.TestPlanServer; -import com.validation.manager.core.server.core.TestProjectServer; -import com.validation.manager.core.server.core.VMUserServer; -import java.util.ArrayList; -import java.util.Date; -import java.util.List; -import java.util.Random; -import java.util.logging.Level; -import java.util.logging.Logger; - -/** - * - * @author Javier Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class DemoBuilder { - - private static final Logger LOG - = Logger.getLogger(DemoBuilder.class.getSimpleName()); - private static int tcCounter = 1, tpCounter, reqCounter; - - public static void buildDemoProject() throws Exception { - LOG.info("Creating demo projects..."); - ProjectJpaController controller - = new ProjectJpaController(DataBaseManager - .getEntityManagerFactory()); - Project rootProject = new Project("Demo"); - controller.create(rootProject); - for (int i = 0; i < 2; i++) { - Project temp = new Project("Sub " + (i + 1)); - temp.setParentProjectId(rootProject); - controller.create(temp); - ProjectServer ps = new ProjectServer(temp); - addDemoProjectRequirements(ps.getEntity()); - addDemoProjectTestProject(ps.getEntity()); - rootProject.getProjectList().add(ps.getEntity()); - } - addDemoProjectRequirements(rootProject); - controller.edit(rootProject); - //Link requirements with steps - List requirements - = new RequirementJpaController(DataBaseManager - .getEntityManagerFactory()) - .findRequirementEntities(); - LOG.log(Level.INFO, "Total: {0}", requirements.size()); - List tcs = new TestCaseJpaController(DataBaseManager - .getEntityManagerFactory()).findTestCaseEntities(); - int amount = tcs.size(); - int size = requirements.size() / amount; - int i = 0; - for (TestCase tc : tcs) { - for (Step step : tc.getStepList()) { - try { - StepServer ss = new StepServer(step); - ss.getRequirementList().addAll(requirements - .subList(i * size, i * size + size)); - ss.write2DB(); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - i++; - } - for (Project p : controller.findProjectEntities()) { - addDemoExecution(p); - } - LOG.info("Done!"); - } - - private static void addDemoProjectRequirements(Project p) - throws Exception { - tpCounter = 1; - reqCounter = 1; - //Create User Needs spec - RequirementSpecServer un = createRequirementSpec(p, 1, 1, 5, - "User Need", "User Need Desc"); - List subSpecs = new ArrayList<>(); - for (int i = 0; i < 5; i++) { - //Create a spec - subSpecs.add(createRequirementSpec(p, 5, 1, 5, "Spec " + i, - "Desc " + i)); - } - //Now link UN requirement to lower level requirements - un.getRequirementSpecNodeList().forEach(rsn -> { - int count = 0; - for (Requirement r : rsn.getRequirementList()) { - subSpecs.get(count).getRequirementSpecNodeList().forEach(nl -> { - nl.getRequirementList().forEach(sr -> { - try { - new RequirementServer(r) - .addChildRequirement(sr); - } - catch (VMException ex) { - LOG.log(Level.SEVERE, null, ex); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - }); - }); - count++; - } - }); - new ProjectJpaController(DataBaseManager - .getEntityManagerFactory()).edit(p); - } - - /** - * Create a requirement spec for the provided project on the specified - * requirement level. - * - * @param p Project to add the spec to. - * @param level Spec level - * @param nodeAmount Amount of nodes to create - * @param reqAmount Amount of requirements to add to each node of this spec. - * @param specName Spec desired name - * @param specDesc Spec description - * @return Created Requirement Spec - * @throws Exception - */ - private static RequirementSpecServer createRequirementSpec(Project p, - int level, int nodeAmount, int reqAmount, String specName, - String specDesc) throws Exception { - RequirementSpecServer temp - = new RequirementSpecServer(specName, - specDesc, - p.getId(), level); - temp.write2DB(); - if (nodeAmount > 0) { - for (int i = 0; i < nodeAmount; i++) { - RequirementSpecNodeServer node - = temp.addSpecNode("Node " + (i + 1), - "Description " + (i + 1), "Scope " + (i + 1)); - if (reqAmount > 0) { - for (int y = 0; y < reqAmount; y++) { - String header = ""; - switch (level) { - case 1: - header = "PS"; - break; - case 5: - header = "SRS"; - break; - default: - header = "SRS"; - break; - } - RequirementServer req - = new RequirementServer(header - + String.format("%05d", reqCounter), - "Description " + reqCounter, - node.getRequirementSpecNodePK(), - "Notes", 1, 1); - req.write2DB(); - node.getRequirementList().add(req.getEntity()); - reqCounter++; - } - } - node.write2DB(); - } - p.getRequirementSpecList().add(temp.getEntity()); - temp.update(); - } - return temp; - } - - private static void addDemoProjectTestProject(Project p) throws - NonexistentEntityException, Exception { - TestProjectServer tp - = new TestProjectServer("Test Project", true); - tp.setName("Test Project"); - tp.setNotes("Notes"); - tp.setActive(true); - tp.write2DB(); - //Add the test structure - TestPlanServer tps = new TestPlanServer(tp.getEntity(), - true, true); - tps.setName("Test Plan #" + (tpCounter++)); - tps.setNotes("Notes"); - tps.write2DB(); - int amount = 5; - for (int i = 0; i < 5; i++) { - //Add steps - TestCaseServer tcs - = new TestCaseServer("Test Case #" - + (tcCounter++), - new Date()); - tcs.write2DB(); - for (int j = 0; j < amount; j++) { - tcs.addStep((j + 1), "Step #" + (j + 1), "Note", - "Criteria", - new ArrayList<>()); - } - tcs.write2DB(); - tps.addTestCase(tcs.getEntity()); - } - ProjectServer ps = new ProjectServer(p); - if (ps.getTestProjectList() == null) { - ps.setTestProjectList(new ArrayList<>()); - } - ps.getTestProjectList().add(tp.getEntity()); - //Save it - ps.write2DB(); - } - - private static void addDemoExecution(Project p) - throws NonexistentEntityException, Exception { - int i = 1; - TestCaseExecutionServer tces - = new TestCaseExecutionServer("Execution " + i, - "Test Scope " + i); - tces.setConclusion("Conclusion!"); - tces.write2DB(); - p.getTestProjectList().forEach((tp) -> { - tces.addTestProject(tp); - }); - tces.write2DB(); - VMUserServer tester1 = new VMUserServer(2);//Tester - VMUserServer tester2 = new VMUserServer(3);//Tester - VMUserServer assigner = new VMUserServer(6);//Tester - Random r = new Random(); - tces.getExecutionStepList().stream().map((es) - -> new ExecutionStepServer(es)).forEachOrdered((ess) - -> { - ess.getStep().getRequirementList().forEach(req -> { - ess.getHistoryList().add(req.getHistoryList().get(0)); - }); - ess.setStepHistory(ess.getStep().getHistoryList().get(0)); - ess.assignUser(r.nextBoolean() ? tester1.getEntity() - : tester2.getEntity(), assigner.getEntity()); - }); - } -} +package com.validation.manager.core; + +import com.validation.manager.core.db.Project; +import com.validation.manager.core.db.Requirement; +import com.validation.manager.core.db.Step; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.controller.ProjectJpaController; +import com.validation.manager.core.db.controller.RequirementJpaController; +import com.validation.manager.core.db.controller.TestCaseJpaController; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.server.core.ExecutionStepServer; +import com.validation.manager.core.server.core.ProjectServer; +import com.validation.manager.core.server.core.RequirementServer; +import com.validation.manager.core.server.core.RequirementSpecNodeServer; +import com.validation.manager.core.server.core.RequirementSpecServer; +import com.validation.manager.core.server.core.StepServer; +import com.validation.manager.core.server.core.TestCaseExecutionServer; +import com.validation.manager.core.server.core.TestCaseServer; +import com.validation.manager.core.server.core.TestPlanServer; +import com.validation.manager.core.server.core.TestProjectServer; +import com.validation.manager.core.server.core.VMUserServer; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Random; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * + * @author Javier Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class DemoBuilder { + + private static final Logger LOG + = Logger.getLogger(DemoBuilder.class.getSimpleName()); + private static int tcCounter = 1, tpCounter, reqCounter; + + public static void buildDemoProject() throws Exception { + LOG.info("Creating demo projects..."); + ProjectJpaController controller + = new ProjectJpaController(DataBaseManager + .getEntityManagerFactory()); + Project rootProject = new Project("Demo"); + controller.create(rootProject); + for (int i = 0; i < 2; i++) { + Project temp = new Project("Sub " + (i + 1)); + temp.setParentProjectId(rootProject); + controller.create(temp); + ProjectServer ps = new ProjectServer(temp); + addDemoProjectRequirements(ps.getEntity()); + addDemoProjectTestProject(ps.getEntity()); + rootProject.getProjectList().add(ps.getEntity()); + } + addDemoProjectRequirements(rootProject); + controller.edit(rootProject); + //Link requirements with steps + List requirements + = new RequirementJpaController(DataBaseManager + .getEntityManagerFactory()) + .findRequirementEntities(); + LOG.log(Level.FINE, "Total Requirements: {0}", requirements.size()); + List tcs = new TestCaseJpaController(DataBaseManager + .getEntityManagerFactory()).findTestCaseEntities(); + int amount = tcs.size(); + int size = requirements.size() / amount; + int i = 0; + for (TestCase tc : tcs) { + for (Step step : tc.getStepList()) { + try { + StepServer ss = new StepServer(step); + ss.getRequirementList().addAll(requirements + .subList(i * size, i * size + size)); + ss.write2DB(); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + i++; + } + for (Project p : controller.findProjectEntities()) { + addDemoExecution(p); + } + LOG.info("Done!"); + } + + private static void addDemoProjectRequirements(Project p) + throws Exception { + tpCounter = 1; + reqCounter = 1; + //Create User Needs spec + RequirementSpecServer un = createRequirementSpec(p, 1, 1, 5, + "User Need", "User Need Desc"); + List subSpecs = new ArrayList<>(); + for (int i = 0; i < 5; i++) { + //Create a spec + subSpecs.add(createRequirementSpec(p, 5, 1, 5, "Spec " + i, + "Desc " + i)); + } + //Now link UN requirement to lower level requirements + un.getRequirementSpecNodeList().forEach(rsn -> { + int count = 0; + for (Requirement r : rsn.getRequirementList()) { + subSpecs.get(count).getRequirementSpecNodeList().forEach(nl -> { + nl.getRequirementList().forEach(sr -> { + try { + new RequirementServer(r) + .addChildRequirement(sr); + } + catch (VMException ex) { + LOG.log(Level.SEVERE, null, ex); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + } + }); + }); + count++; + } + }); + new ProjectJpaController(DataBaseManager + .getEntityManagerFactory()).edit(p); + } + + /** + * Create a requirement spec for the provided project on the specified + * requirement level. + * + * @param p Project to add the spec to. + * @param level Spec level + * @param nodeAmount Amount of nodes to create + * @param reqAmount Amount of requirements to add to each node of this spec. + * @param specName Spec desired name + * @param specDesc Spec description + * @return Created Requirement Spec + * @throws Exception + */ + private static RequirementSpecServer createRequirementSpec(Project p, + int level, int nodeAmount, int reqAmount, String specName, + String specDesc) throws Exception { + RequirementSpecServer temp + = new RequirementSpecServer(specName, + specDesc, + p.getId(), level); + temp.write2DB(); + if (nodeAmount > 0) { + for (int i = 0; i < nodeAmount; i++) { + RequirementSpecNodeServer node + = temp.addSpecNode("Node " + (i + 1), + "Description " + (i + 1), "Scope " + (i + 1)); + if (reqAmount > 0) { + for (int y = 0; y < reqAmount; y++) { + String header = ""; + switch (level) { + case 1: + header = "PS"; + break; + case 5: + header = "SRS"; + break; + default: + header = "SRS"; + break; + } + RequirementServer req + = new RequirementServer(header + + String.format("%05d", reqCounter), + "Description " + reqCounter, + node.getRequirementSpecNodePK(), + "Notes", 1, 1); + req.write2DB(); + node.getRequirementList().add(req.getEntity()); + reqCounter++; + } + } + node.write2DB(); + } + p.getRequirementSpecList().add(temp.getEntity()); + temp.update(); + } + return temp; + } + + private static void addDemoProjectTestProject(Project p) throws + NonexistentEntityException, Exception { + TestProjectServer tp + = new TestProjectServer("Test Project", true); + tp.setName("Test Project"); + tp.setNotes("Notes"); + tp.setActive(true); + tp.write2DB(); + //Add the test structure + TestPlanServer tps = new TestPlanServer(tp.getEntity(), + true, true); + tps.setName("Test Plan #" + (tpCounter++)); + tps.setNotes("Notes"); + tps.write2DB(); + int amount = 5; + for (int i = 0; i < 5; i++) { + //Add steps + TestCaseServer tcs + = new TestCaseServer("Test Case #" + + (tcCounter++), + new Date()); + tcs.write2DB(); + for (int j = 0; j < amount; j++) { + tcs.addStep((j + 1), "Step #" + (j + 1), "Note", + "Criteria", + new ArrayList<>()); + } + tcs.write2DB(); + tps.addTestCase(tcs.getEntity()); + } + ProjectServer ps = new ProjectServer(p); + if (ps.getTestProjectList() == null) { + ps.setTestProjectList(new ArrayList<>()); + } + ps.getTestProjectList().add(tp.getEntity()); + //Save it + ps.write2DB(); + } + + private static void addDemoExecution(Project p) + throws NonexistentEntityException, Exception { + int i = 1; + TestCaseExecutionServer tces + = new TestCaseExecutionServer("Execution " + i, + "Test Scope " + i); + tces.setConclusion("Conclusion!"); + tces.write2DB(); + p.getTestProjectList().forEach((tp) -> { + tces.addTestProject(tp); + }); + tces.write2DB(); + VMUserServer tester1 = new VMUserServer(2);//Tester + VMUserServer tester2 = new VMUserServer(3);//Tester + VMUserServer assigner = new VMUserServer(6);//Tester + Random r = new Random(); + tces.getExecutionStepList().stream().map((es) + -> new ExecutionStepServer(es)).forEachOrdered((ess) + -> { + ess.getStep().getRequirementList().forEach(req -> { + ess.getHistoryList().add(req.getHistoryList().get(0)); + }); + ess.setStepHistory(ess.getStep().getHistoryList().get(0)); + ess.assignUser(r.nextBoolean() ? tester1.getEntity() + : tester2.getEntity(), assigner.getEntity()); + }); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/EntityServer.java b/VM-Core/src/main/java/com/validation/manager/core/EntityServer.java index 9b82bb85..818a26ef 100755 --- a/VM-Core/src/main/java/com/validation/manager/core/EntityServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/EntityServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,46 +13,46 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core; - -import java.util.HashMap; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - * @param Entity - */ -public interface EntityServer { - - static HashMap PARAMETERS = new HashMap(); - - /** - * Write Entity to database - * - * @return Id for entity (new if just created) - * @throws Exception if there was an issue updating the database. - */ - public int write2DB() throws Exception; - - /** - * Gets the entity represented by this EntityServer. Easy method to access - * underlying entity for use with controllers and such. - * - * @return The entity. - */ - public T getEntity(); - - /** - * Update the target with the source object. - * - * @param target object to update. - * @param source object to update from. - */ - public void update(T target, T source); - - /** - * Update the enclosed entity. - * - */ - public void update(); -} +package com.validation.manager.core; + +import java.util.HashMap; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + * @param Entity + */ +public interface EntityServer { + + static HashMap PARAMETERS = new HashMap(); + + /** + * Write Entity to database + * + * @return Id for entity (new if just created) + * @throws Exception if there was an issue updating the database. + */ + public int write2DB() throws Exception; + + /** + * Gets the entity represented by this EntityServer. Easy method to access + * underlying entity for use with controllers and such. + * + * @return The entity. + */ + public T getEntity(); + + /** + * Update the target with the source object. + * + * @param target object to update. + * @param source object to update from. + */ + public void update(T target, T source); + + /** + * Update the enclosed entity. + * + */ + public void update(); +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/ImportException.java b/VM-Core/src/main/java/com/validation/manager/core/ImportException.java deleted file mode 100644 index 2f8ac722..00000000 --- a/VM-Core/src/main/java/com/validation/manager/core/ImportException.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.validation.manager.core; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class ImportException extends VMException { - -} diff --git a/VM-Core/src/main/java/com/validation/manager/core/ImporterInterface.java b/VM-Core/src/main/java/com/validation/manager/core/ImporterInterface.java index 6be248cd..29072572 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/ImporterInterface.java +++ b/VM-Core/src/main/java/com/validation/manager/core/ImporterInterface.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,39 +13,39 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core; - -import java.util.List; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - * @param Class type for template. - */ -public interface ImporterInterface { - - /** - * Import the file. - * - * @return List of imported entities - * @throws ImportException If something goes wrong in the importing process. - */ - List importFile() throws VMException; - - /** - * Import the file. - * - * @param header File has header row. - * @return List of imported entities - * @throws ImportException If something goes wrong in the importing process. - */ - List importFile(boolean header) throws VMException; - - /** - * Process the imported data. - * - * @return true if processed successfully, false otherwise. - * @throws VMException if there was an issue during import. - */ - boolean processImport() throws VMException; -} +package com.validation.manager.core; + +import java.util.List; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + * @param Class type for template. + */ +public interface ImporterInterface { + + /** + * Import the file. + * + * @return List of imported entities + * @throws VMException If something goes wrong in the importing process. + */ + List importFile() throws VMException; + + /** + * Import the file. + * + * @param header File has header row. + * @return List of imported entities + * @throws VMException If something goes wrong in the importing process. + */ + List importFile(boolean header) throws VMException; + + /** + * Process the imported data. + * + * @return true if processed successfully, false otherwise. + * @throws VMException if there was an issue during import. + */ + boolean processImport() throws VMException; +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/VMIdGenerator.java b/VM-Core/src/main/java/com/validation/manager/core/VMIdGenerator.java deleted file mode 100755 index 76f263b4..00000000 --- a/VM-Core/src/main/java/com/validation/manager/core/VMIdGenerator.java +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.validation.manager.core; - -import static com.validation.manager.core.DataBaseManager.namedQuery; -import com.validation.manager.core.db.VmId; -import java.util.HashMap; -import java.util.logging.Level; -import java.util.logging.Logger; -import static java.util.logging.Logger.getLogger; -import javax.persistence.PrePersist; - -/** - * Work around issue with sequencing on H2 databases on Linux - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class VMIdGenerator { - - private static final Logger LOG - = getLogger(VMIdGenerator.class.getSimpleName()); - - /** - * Just before persisting an entity. - * - * @param o object to be persisted - * @throws Exception if something goes wrong - */ - @PrePersist - public void persistEntity(Object o) throws Exception { - LOG.log(Level.FINE, "Pre-persist: {0}", o); - if (o instanceof VmId) { - VmId vmId = (VmId) o; - if (vmId.getId() == null || vmId.getId() <= 0) { - LOG.log(Level.FINE, "Detected: {0}, fixing id...", vmId); - HashMap parameters = new HashMap<>(); - int id = namedQuery("VmId.findAll").size() + 1; - while (vmId.getId() <= 0) { - parameters.put("id", id); - if (namedQuery("VmId.findById", parameters).isEmpty()) { - vmId.setId(id); - LOG.log(Level.FINE, "Assigned id: {0} to {1}", - new Object[]{id, vmId.getTableName()}); - } else { - id++; - } - } - } - } - } -} diff --git a/VM-Core/src/main/java/com/validation/manager/core/VaadinUtils.java b/VM-Core/src/main/java/com/validation/manager/core/VaadinUtils.java index 5d177b4a..41c4a185 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/VaadinUtils.java +++ b/VM-Core/src/main/java/com/validation/manager/core/VaadinUtils.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,162 +13,162 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core; - -import com.vaadin.data.Property; -import com.vaadin.ui.Component; -import com.vaadin.ui.HasComponents; -import com.vaadin.ui.UI; -import java.io.UnsupportedEncodingException; -import java.util.Collections; -import java.util.Enumeration; -import java.util.Locale; -import java.util.ResourceBundle; -import java.util.SortedSet; -import java.util.TreeSet; -import java.util.logging.Level; -import java.util.logging.Logger; - -/** - * {@code VaadinUtils} offers some utility functions for the - * Vaadin UI Framework. - * - * @author Javier Ortiz Bultron - * Based on code from: Ronald K. Muller - * https://gist.github.com/rmuller/10980706 - */ -public final class VaadinUtils { - - private static final Logger LOG - = Logger.getLogger(VaadinUtils.class.getSimpleName()); - - // Utility class - private VaadinUtils() { - } - - /** - * Change all {@code Locale} dependant properties of the - * {@code com.vaadin.ui.Component}s within of the given component container - * (typically an {@link UI} or other top level layout component). If the - * specified {@code Locale} is the same as the current {@code Locale} of the - * component container, this method does nothing. Otherwise it'll go thru - * the components searching for it's component id. If it is in the resource - * bundle, it'll set it's caption to the right translated string. - * - *

- * To use this method, do something like: - * 

-     * public class MyUI extends UI {
-     *
-     *     {@literal @}Override
-     *     public void init(final VaadinRequest request) {
-     *         // ... usual code
-     *         // somewhere in the UI the user can change the "Form Locale". This code must
-     *         // call myUI#setLocale(newLocale);
-     *     }
-     *
-     *     // ...
-     *
-     * }
-     *
-     *      String key = "demo.tab.message";
-     *      VerticalLayout vl = new VerticalLayout();
-     *      Button b = new Button(key);
-     *      vl.addComponent(b);
-     *      ResourceBundle rb = ResourceBundle.getBundle(
-     *              "resource.bundle",
-     *              new Locale("es"));
-     *      VaadinUtils.updateLocale(vl, new Locale("es"), rb);
-     *
-     *      It also works with components implementing Property:
-     *
-     *      VerticalLayout vl = new VerticalLayout();
-     *      Label l = new Label(key);
-     *      vl.addComponent(l);
-     *      ResourceBundle rb = ResourceBundle.getBundle(
-     *              "resource.bundle",
-     *              new Locale("es"));
-     *      VaadinUtils.updateLocale(vl, new Locale("es"), rb);
-     *
- * - * @param ui The component container for which the {@code Locale} dependent - * component properties must be changed, never {@code null} - * @param locale The new {@code Locale}, never {@code null} - * @param rb The {@code ResourceBundle} for the specified {@code Locale}, - * never {@code null} - */ - public static void updateLocale(final HasComponents ui, final Locale locale, - final ResourceBundle rb) { - - // locale may not be null, however the current UI Locale may be null! - if (locale.equals(ui.getLocale())) { - return; - } - final long time = System.currentTimeMillis(); - walkComponentTree(ui, (Component c) -> { - String id = c.getId(); - String caption; - if (c instanceof Property - && ((Property) c).getValue() instanceof String) { - caption = (String) ((Property) c).getValue(); - } else { - caption = c.getCaption(); - } - if (id != null && !id.trim().isEmpty()) { - if (rb.containsKey(id)) { - try { - c.setCaption(new String(rb.getString(id) - .getBytes("ISO-8859-1"), "UTF-8")); - } - catch (UnsupportedEncodingException ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - } else if (caption != null && !caption.trim().isEmpty()) { - /** - * This is a more complex scenario where the caption uses more - * than one key for translation. Sort the keys in reverse so - * substitutions are correct. - */ - final SortedSet ss = new TreeSet<>(Collections.reverseOrder()); - for (Enumeration e = rb.getKeys(); e.hasMoreElements();) { - try { - String key = e.nextElement(); - ss.add(key); - caption = caption.replaceAll(key, new String(rb.getString(key) - .getBytes("ISO-8859-1"), "UTF-8")); - } - catch (UnsupportedEncodingException ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - if (c instanceof Property) { - ((Property) c).setValue(caption); - } else { - c.setCaption(caption); - } - } - }); - LOG.log(Level.INFO, "Locale updated: {0} -> {1} in {2} ms.", - new Object[]{ui.getLocale(), locale, - System.currentTimeMillis() - time}); - } - - // private - // if switching to Java 8, remove this and replace by java.util.funtion.Consumer - // (and make to code more functional) - interface Consumer { - - void accept(T t); - } - - // recursively walk the Component true - private static void walkComponentTree(Component c, Consumer visitor) { - visitor.accept(c); - if (c instanceof HasComponents) { - for (Component child : ((HasComponents) c)) { - walkComponentTree(child, visitor); - } - } - } -} +package com.validation.manager.core; + +import com.vaadin.data.Property; +import com.vaadin.ui.Component; +import com.vaadin.ui.HasComponents; +import com.vaadin.ui.UI; +import java.io.UnsupportedEncodingException; +import java.util.Collections; +import java.util.Enumeration; +import java.util.Locale; +import java.util.ResourceBundle; +import java.util.SortedSet; +import java.util.TreeSet; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * {@code VaadinUtils} offers some utility functions for the + * Vaadin UI Framework. + * + * @author Javier Ortiz Bultron + * Based on code from: Ronald K. Muller + * https://gist.github.com/rmuller/10980706 + */ +public final class VaadinUtils { + + private static final Logger LOG + = Logger.getLogger(VaadinUtils.class.getSimpleName()); + + // Utility class + private VaadinUtils() { + } + + /** + * Change all {@code Locale} dependant properties of the + * {@code com.vaadin.ui.Component}s within of the given component container + * (typically an {@link UI} or other top level layout component). If the + * specified {@code Locale} is the same as the current {@code Locale} of the + * component container, this method does nothing. Otherwise it'll go thru + * the components searching for it's component id. If it is in the resource + * bundle, it'll set it's caption to the right translated string. + * + *

+ * To use this method, do something like: + * 

+     * public class MyUI extends UI {
+     *
+     *     {@literal @}Override
+     *     public void init(final VaadinRequest request) {
+     *         // ... usual code
+     *         // somewhere in the UI the user can change the "Form Locale". This code must
+     *         // call myUI#setLocale(newLocale);
+     *     }
+     *
+     *     // ...
+     *
+     * }
+     *
+     *      String key = "demo.tab.message";
+     *      VerticalLayout vl = new VerticalLayout();
+     *      Button b = new Button(key);
+     *      vl.addComponent(b);
+     *      ResourceBundle rb = ResourceBundle.getBundle(
+     *              "resource.bundle",
+     *              new Locale("es"));
+     *      VaadinUtils.updateLocale(vl, new Locale("es"), rb);
+     *
+     *      It also works with components implementing Property:
+     *
+     *      VerticalLayout vl = new VerticalLayout();
+     *      Label l = new Label(key);
+     *      vl.addComponent(l);
+     *      ResourceBundle rb = ResourceBundle.getBundle(
+     *              "resource.bundle",
+     *              new Locale("es"));
+     *      VaadinUtils.updateLocale(vl, new Locale("es"), rb);
+     *
+ * + * @param ui The component container for which the {@code Locale} dependent + * component properties must be changed, never {@code null} + * @param locale The new {@code Locale}, never {@code null} + * @param rb The {@code ResourceBundle} for the specified {@code Locale}, + * never {@code null} + */ + public static void updateLocale(final HasComponents ui, final Locale locale, + final ResourceBundle rb) { + + // locale may not be null, however the current UI Locale may be null! + if (locale.equals(ui.getLocale())) { + return; + } + final long time = System.currentTimeMillis(); + walkComponentTree(ui, (Component c) -> { + String id = c.getId(); + String caption; + if (c instanceof Property + && ((Property) c).getValue() instanceof String) { + caption = (String) ((Property) c).getValue(); + } else { + caption = c.getCaption(); + } + if (id != null && !id.trim().isEmpty()) { + if (rb.containsKey(id)) { + try { + c.setCaption(new String(rb.getString(id) + .getBytes("ISO-8859-1"), "UTF-8")); + } + catch (UnsupportedEncodingException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + } else if (caption != null && !caption.trim().isEmpty()) { + /** + * This is a more complex scenario where the caption uses more + * than one key for translation. Sort the keys in reverse so + * substitutions are correct. + */ + final SortedSet ss = new TreeSet<>(Collections.reverseOrder()); + for (Enumeration e = rb.getKeys(); e.hasMoreElements();) { + try { + String key = e.nextElement(); + ss.add(key); + caption = caption.replaceAll(key, new String(rb.getString(key) + .getBytes("ISO-8859-1"), "UTF-8")); + } + catch (UnsupportedEncodingException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + if (c instanceof Property) { + ((Property) c).setValue(caption); + } else { + c.setCaption(caption); + } + } + }); + LOG.log(Level.FINE, "Locale updated: {0} -> {1} in {2} ms.", + new Object[]{ui.getLocale(), locale, + System.currentTimeMillis() - time}); + } + + // private + // if switching to Java 8, remove this and replace by java.util.funtion.Consumer + // (and make to code more functional) + interface Consumer { + + void accept(T t); + } + + // recursively walk the Component true + private static void walkComponentTree(Component c, Consumer visitor) { + visitor.accept(c); + if (c instanceof HasComponents) { + for (Component child : ((HasComponents) c)) { + walkComponentTree(child, visitor); + } + } + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/adapter/TimestampAdapter.java b/VM-Core/src/main/java/com/validation/manager/core/adapter/TimestampAdapter.java deleted file mode 100644 index 63edb98b..00000000 --- a/VM-Core/src/main/java/com/validation/manager/core/adapter/TimestampAdapter.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.validation.manager.core.adapter; - -import java.sql.Timestamp; -import java.util.Date; -import javax.xml.bind.annotation.adapters.XmlAdapter; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class TimestampAdapter extends XmlAdapter { - - @Override - public Timestamp unmarshal(Date v) throws Exception { - if (v == null) { - return null; - } else { - return new Timestamp(v.getTime()); - } - } - - @Override - public Date marshal(Timestamp v) throws Exception { - if (v == null) { - return null; - } else { - return new Date(v.getTime()); - } - } -} diff --git a/VM-Core/src/main/java/com/validation/manager/core/tool/step/importer/StepImportException.java b/VM-Core/src/main/java/com/validation/manager/core/api/email/IEmailManager.java similarity index 55% rename from VM-Core/src/main/java/com/validation/manager/core/tool/step/importer/StepImportException.java rename to VM-Core/src/main/java/com/validation/manager/core/api/email/IEmailManager.java index 26091df3..8be830e8 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/tool/step/importer/StepImportException.java +++ b/VM-Core/src/main/java/com/validation/manager/core/api/email/IEmailManager.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,23 +13,26 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.tool.step.importer; - -import static java.util.Locale.getDefault; -import java.util.ResourceBundle; -import static java.util.ResourceBundle.getBundle; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class StepImportException extends Exception { - - private static final ResourceBundle RB - = getBundle("com.validation.manager.resources.VMMessages", - getDefault()); - - public StepImportException(String message) { - super(RB.containsKey(message) ? RB.getString(message) : message); - } -} +package com.validation.manager.core.api.email; + +import javax.mail.MessagingException; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public interface IEmailManager { + + /** + * Create an email message. + * + * @param to Recipient email + * @param cc Email to copy to + * @param from Sender email + * @param subject Subject + * @param bodyText Message + * @throws MessagingException If there's an error sending the message + */ + void sendEmail(String to, String cc, String from, + String subject, String bodyText) throws MessagingException; +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/api/internationalization/InternationalizationProvider.java b/VM-Core/src/main/java/com/validation/manager/core/api/internationalization/InternationalizationProvider.java index d9b47f8d..d4f48fc5 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/api/internationalization/InternationalizationProvider.java +++ b/VM-Core/src/main/java/com/validation/manager/core/api/internationalization/InternationalizationProvider.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,28 +13,38 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.api.internationalization; - -import java.util.ResourceBundle; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public interface InternationalizationProvider extends LocaleListener { - - /** - * Translate a string. - * - * @param mess String to translate - * @return Translated string or the same string if no translation found. - */ - public String translate(String mess); - - /** - * Get the ResourceBundle. - * - * @return The resource bundle. - */ - public ResourceBundle getResourceBundle(); -} +package com.validation.manager.core.api.internationalization; + +import java.util.Locale; +import java.util.ResourceBundle; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public interface InternationalizationProvider { + + /** + * Translate a string. + * + * @param mess String to translate + * @return Translated string or the same string if no translation found. + */ + public String translate(String mess); + + /** + * Translate a string. + * + * @param mess String to translate + * @param l Locale to translate into. + * @return Translated string or the same string if no translation found. + */ + public String translate(String mess, Locale l); + + /** + * Get the ResourceBundle. + * + * @return The resource bundle. + */ + public ResourceBundle getResourceBundle(); +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/AssigmentType.java b/VM-Core/src/main/java/com/validation/manager/core/db/AssigmentType.java index cb095ed2..9be79510 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/AssigmentType.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/AssigmentType.java @@ -13,131 +13,131 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.Lob; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "assigment_type") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "AssigmentType.findAll", - query = "SELECT a FROM AssigmentType a") - , @NamedQuery(name = "AssigmentType.findById", - query = "SELECT a FROM AssigmentType a WHERE a.id = :id") - , @NamedQuery(name = "AssigmentType.findByFkTable", - query = "SELECT a FROM AssigmentType a WHERE a.fkTable = :fkTable")}) -public class AssigmentType implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "Assignment_Type_IDGEN") - @TableGenerator(name = "Assignment_Type_IDGEN", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "assigment_type", - initialValue = 1000, - allocationSize = 1) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "fk_table") - private String fkTable; - @Lob - @Size(max = 2147483647) - @Column(name = "description") - private String description; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "assigmentType") - private List userAssigmentList; - - public AssigmentType() { - } - - public AssigmentType(String fkTable) { - this.fkTable = fkTable; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getFkTable() { - return fkTable; - } - - public void setFkTable(String fkTable) { - this.fkTable = fkTable; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getUserAssigmentList() { - return userAssigmentList; - } - - public void setUserAssigmentList(List userAssigmentList) { - this.userAssigmentList = userAssigmentList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof AssigmentType)) { - return false; - } - AssigmentType other = (AssigmentType) object; - return (this.id.equals(other.id)); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.AssigmentType[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "assigment_type") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "AssigmentType.findAll", + query = "SELECT a FROM AssigmentType a") + , @NamedQuery(name = "AssigmentType.findById", + query = "SELECT a FROM AssigmentType a WHERE a.id = :id") + , @NamedQuery(name = "AssigmentType.findByFkTable", + query = "SELECT a FROM AssigmentType a WHERE a.fkTable = :fkTable")}) +public class AssigmentType implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "Assignment_Type_IDGEN") + @TableGenerator(name = "Assignment_Type_IDGEN", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "assigment_type", + initialValue = 1_000, + allocationSize = 1) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "fk_table") + private String fkTable; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "description") + private String description; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "assigmentType") + private List userAssigmentList; + + public AssigmentType() { + } + + public AssigmentType(String fkTable) { + this.fkTable = fkTable; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getFkTable() { + return fkTable; + } + + public void setFkTable(String fkTable) { + this.fkTable = fkTable; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getUserAssigmentList() { + return userAssigmentList; + } + + public void setUserAssigmentList(List userAssigmentList) { + this.userAssigmentList = userAssigmentList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof AssigmentType)) { + return false; + } + AssigmentType other = (AssigmentType) object; + return (this.id.equals(other.id)); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.AssigmentType[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/AssignmentStatus.java b/VM-Core/src/main/java/com/validation/manager/core/db/AssignmentStatus.java index 3dc1809c..3db70fa0 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/AssignmentStatus.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/AssignmentStatus.java @@ -13,134 +13,134 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.Lob; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "assignment_status") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "AssignmentStatus.findAll", - query = "SELECT a FROM AssignmentStatus a") - , @NamedQuery(name = "AssignmentStatus.findById", - query = "SELECT a FROM AssignmentStatus a WHERE a.id = :id") - , @NamedQuery(name = "AssignmentStatus.findByName", - query = "SELECT a FROM AssignmentStatus a WHERE a.name = :name")}) -public class AssignmentStatus implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "Assignment_Status_IDGEN") - @TableGenerator(name = "Assignment_Status_IDGEN", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "assigment_status", - initialValue = 1000, - allocationSize = 1) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Basic(optional = false) - @NotNull - @Lob - @Size(max = 2147483647) - @Column(name = "description") - private String description; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "assignmentStatus") - private List userAssigmentList; - - public AssignmentStatus() { - } - - public AssignmentStatus(String name, String description) { - this.name = name; - this.description = description; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getUserAssigmentList() { - return userAssigmentList; - } - - public void setUserAssigmentList(List userAssigmentList) { - this.userAssigmentList = userAssigmentList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof AssignmentStatus)) { - return false; - } - AssignmentStatus other = (AssignmentStatus) object; - return (this.id.equals(other.id)); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.AssignmentStatus[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "assignment_status") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "AssignmentStatus.findAll", + query = "SELECT a FROM AssignmentStatus a") + , @NamedQuery(name = "AssignmentStatus.findById", + query = "SELECT a FROM AssignmentStatus a WHERE a.id = :id") + , @NamedQuery(name = "AssignmentStatus.findByName", + query = "SELECT a FROM AssignmentStatus a WHERE a.name = :name")}) +public class AssignmentStatus implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "Assignment_Status_IDGEN") + @TableGenerator(name = "Assignment_Status_IDGEN", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "assigment_status", + initialValue = 1_000, + allocationSize = 1) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Basic(optional = false) + @NotNull + @Lob + @Size(max = 2_147_483_647) + @Column(name = "description") + private String description; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "assignmentStatus") + private List userAssigmentList; + + public AssignmentStatus() { + } + + public AssignmentStatus(String name, String description) { + this.name = name; + this.description = description; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getUserAssigmentList() { + return userAssigmentList; + } + + public void setUserAssigmentList(List userAssigmentList) { + this.userAssigmentList = userAssigmentList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof AssignmentStatus)) { + return false; + } + AssignmentStatus other = (AssignmentStatus) object; + return (this.id.equals(other.id)); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.AssignmentStatus[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Attachment.java b/VM-Core/src/main/java/com/validation/manager/core/db/Attachment.java index 781a7810..cace5615 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Attachment.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Attachment.java @@ -13,160 +13,160 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.EmbeddedId; -import javax.persistence.Entity; -import javax.persistence.JoinColumn; -import javax.persistence.Lob; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "attachment") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Attachment.findAll", - query = "SELECT a FROM Attachment a") - , @NamedQuery(name = "Attachment.findById", - query = "SELECT a FROM Attachment a WHERE a.attachmentPK.id = :id") - , @NamedQuery(name = "Attachment.findByAttachmentTypeId", - query = "SELECT a FROM Attachment a WHERE a.attachmentPK.attachmentTypeId = :attachmentTypeId") - , @NamedQuery(name = "Attachment.findByStringValue", - query = "SELECT a FROM Attachment a WHERE a.stringValue = :stringValue") - , @NamedQuery(name = "Attachment.findByFileName", - query = "SELECT a FROM Attachment a WHERE a.fileName = :fileName")}) -public class Attachment implements Serializable { - - private static final long serialVersionUID = 1L; - @EmbeddedId - protected AttachmentPK attachmentPK; - @Size(max = 255) - @Column(name = "string_value") - private String stringValue; - @Lob - @Column(name = "file") - private byte[] file; - @Lob - @Size(max = 2147483647) - @Column(name = "TEXT_VALUE") - private String textValue; - @Size(max = 255) - @Column(name = "file_name") - private String fileName; - @JoinColumn(name = "attachment_type_id", referencedColumnName = "id", - insertable = false, updatable = false) - @ManyToOne(optional = false) - private AttachmentType attachmentType; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "attachment") - private List executionStepHasAttachmentList; - - public Attachment() { - } - - public Attachment(AttachmentPK attachmentPK) { - this.attachmentPK = attachmentPK; - } - - public Attachment(int id, int attachmentTypeId) { - this.attachmentPK = new AttachmentPK(id, attachmentTypeId); - } - - public AttachmentPK getAttachmentPK() { - return attachmentPK; - } - - public void setAttachmentPK(AttachmentPK attachmentPK) { - this.attachmentPK = attachmentPK; - } - - public String getStringValue() { - return stringValue; - } - - public void setStringValue(String stringValue) { - this.stringValue = stringValue; - } - - public String getTextValue() { - return textValue; - } - - public void setTextValue(String textValue) { - this.textValue = textValue; - } - - public String getFileName() { - return fileName; - } - - public void setFileName(String fileName) { - this.fileName = fileName; - } - - public AttachmentType getAttachmentType() { - return attachmentType; - } - - public void setAttachmentType(AttachmentType attachmentType) { - this.attachmentType = attachmentType; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepHasAttachmentList() { - return executionStepHasAttachmentList; - } - - public void setExecutionStepHasAttachmentList(List executionStepHasAttachmentList) { - this.executionStepHasAttachmentList = executionStepHasAttachmentList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (attachmentPK != null ? attachmentPK.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof Attachment)) { - return false; - } - Attachment other = (Attachment) object; - return !((this.attachmentPK == null && other.attachmentPK != null) - || (this.attachmentPK != null - && !this.attachmentPK.equals(other.attachmentPK))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Attachment[ attachmentPK=" - + attachmentPK + " ]"; - } - - public byte[] getFile() { - return file; - } - - public void setFile(byte[] file) { - this.file = file; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.Lob; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "attachment") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Attachment.findAll", + query = "SELECT a FROM Attachment a") + , @NamedQuery(name = "Attachment.findById", + query = "SELECT a FROM Attachment a WHERE a.attachmentPK.id = :id") + , @NamedQuery(name = "Attachment.findByAttachmentTypeId", + query = "SELECT a FROM Attachment a WHERE a.attachmentPK.attachmentTypeId = :attachmentTypeId") + , @NamedQuery(name = "Attachment.findByStringValue", + query = "SELECT a FROM Attachment a WHERE a.stringValue = :stringValue") + , @NamedQuery(name = "Attachment.findByFileName", + query = "SELECT a FROM Attachment a WHERE a.fileName = :fileName")}) +public class Attachment implements Serializable { + + private static final long serialVersionUID = 1L; + @EmbeddedId + protected AttachmentPK attachmentPK; + @Size(max = 255) + @Column(name = "string_value") + private String stringValue; + @Lob + @Column(name = "file") + private byte[] file; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "TEXT_VALUE") + private String textValue; + @Size(max = 255) + @Column(name = "file_name") + private String fileName; + @JoinColumn(name = "attachment_type_id", referencedColumnName = "id", + insertable = false, updatable = false) + @ManyToOne(optional = false) + private AttachmentType attachmentType; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "attachment") + private List executionStepHasAttachmentList; + + public Attachment() { + } + + public Attachment(AttachmentPK attachmentPK) { + this.attachmentPK = attachmentPK; + } + + public Attachment(int id, int attachmentTypeId) { + this.attachmentPK = new AttachmentPK(id, attachmentTypeId); + } + + public AttachmentPK getAttachmentPK() { + return attachmentPK; + } + + public void setAttachmentPK(AttachmentPK attachmentPK) { + this.attachmentPK = attachmentPK; + } + + public String getStringValue() { + return stringValue; + } + + public void setStringValue(String stringValue) { + this.stringValue = stringValue; + } + + public String getTextValue() { + return textValue; + } + + public void setTextValue(String textValue) { + this.textValue = textValue; + } + + public String getFileName() { + return fileName; + } + + public void setFileName(String fileName) { + this.fileName = fileName; + } + + public AttachmentType getAttachmentType() { + return attachmentType; + } + + public void setAttachmentType(AttachmentType attachmentType) { + this.attachmentType = attachmentType; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepHasAttachmentList() { + return executionStepHasAttachmentList; + } + + public void setExecutionStepHasAttachmentList(List executionStepHasAttachmentList) { + this.executionStepHasAttachmentList = executionStepHasAttachmentList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (attachmentPK != null ? attachmentPK.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof Attachment)) { + return false; + } + Attachment other = (Attachment) object; + return !((this.attachmentPK == null && other.attachmentPK != null) + || (this.attachmentPK != null + && !this.attachmentPK.equals(other.attachmentPK))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Attachment[ attachmentPK=" + + attachmentPK + " ]"; + } + + public byte[] getFile() { + return file; + } + + public void setFile(byte[] file) { + this.file = file; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/AttachmentType.java b/VM-Core/src/main/java/com/validation/manager/core/db/AttachmentType.java index 247ae686..2015e8f8 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/AttachmentType.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/AttachmentType.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,125 +13,120 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.Id; -import javax.persistence.Lob; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "attachment_type") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "AttachmentType.findAll", - query = "SELECT a FROM AttachmentType a") - , @NamedQuery(name = "AttachmentType.findById", - query = "SELECT a FROM AttachmentType a WHERE a.id = :id") - , @NamedQuery(name = "AttachmentType.findByType", - query = "SELECT a FROM AttachmentType a WHERE a.type = :type")}) -public class AttachmentType implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @NotNull - @Column(name = "id") - private Integer id; - @Lob - @Size(max = 65535) - @Column(name = "description") - private String description; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "TYPE") - private String type; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "attachmentType") - private List attachmentList; - - public AttachmentType() { - } - - public AttachmentType(Integer id) { - this.id = id; - } - - public AttachmentType(Integer id, String type) { - this.id = id; - this.type = type; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - public String getType() { - return type; - } - - public void setType(String type) { - this.type = type; - } - - @XmlTransient - @JsonIgnore - public List getAttachmentList() { - return attachmentList; - } - - public void setAttachmentList(List attachmentList) { - this.attachmentList = attachmentList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof AttachmentType)) { - return false; - } - AttachmentType other = (AttachmentType) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.AttachmentType[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "attachment_type") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "AttachmentType.findAll", + query = "SELECT a FROM AttachmentType a") + , @NamedQuery(name = "AttachmentType.findById", + query = "SELECT a FROM AttachmentType a WHERE a.id = :id") + , @NamedQuery(name = "AttachmentType.findByType", + query = "SELECT a FROM AttachmentType a WHERE a.type = :type")}) +public class AttachmentType implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @NotNull + @Column(name = "id") + private Integer id; + @Lob + @Size(max = 65_535) + @Column(name = "description") + private String description; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "TYPE") + private String type; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "attachmentType") + private List attachmentList; + + public AttachmentType() { + } + + public AttachmentType(String type) { + this.type = type; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + @XmlTransient + @JsonIgnore + public List getAttachmentList() { + return attachmentList; + } + + public void setAttachmentList(List attachmentList) { + this.attachmentList = attachmentList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof AttachmentType)) { + return false; + } + AttachmentType other = (AttachmentType) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.AttachmentType[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Baseline.java b/VM-Core/src/main/java/com/validation/manager/core/db/Baseline.java index e6e11160..91a3cc0b 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Baseline.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Baseline.java @@ -13,176 +13,176 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.Date; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinColumns; -import javax.persistence.JoinTable; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "baseline") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Baseline.findAll", - query = "SELECT b FROM Baseline b") - , @NamedQuery(name = "Baseline.findById", - query = "SELECT b FROM Baseline b WHERE b.id = :id") - , @NamedQuery(name = "Baseline.findByCreationDate", - query = "SELECT b FROM Baseline b WHERE b.creationDate = :creationDate") - , @NamedQuery(name = "Baseline.findByBaselineName", - query = "SELECT b FROM Baseline b WHERE b.baselineName = :baselineName")}) -public class Baseline implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @NotNull - @Column(name = "id") - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "Baseline_IDGEN") - @TableGenerator(name = "Baseline_IDGEN", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "baseline", - initialValue = 1, - allocationSize = 1) - private Integer id; - @Basic(optional = false) - @NotNull - @Column(name = "creation_date") - @Temporal(TemporalType.TIMESTAMP) - private Date creationDate; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "baseline_name") - private String baselineName; - @Lob - @Size(max = 2147483647) - @Column(name = "description") - private String description; - @JoinTable(name = "baseline_has_history", joinColumns = { - @JoinColumn(name = "baseline_id", referencedColumnName = "id")}, inverseJoinColumns = { - @JoinColumn(name = "history_id", referencedColumnName = "id")}) - @ManyToMany - private List historyList; - @JoinColumns({ - @JoinColumn(name = "requirement_spec_id", referencedColumnName = "id") - , @JoinColumn(name = "requirement_spec_project_id", referencedColumnName = "project_id") - , @JoinColumn(name = "requirement_spec_spec_level_id", referencedColumnName = "spec_level_id")}) - @ManyToOne(optional = false) - private RequirementSpec requirementSpec; - - public Baseline() { - } - - public Baseline(Date creationDate, String baselineName) { - this.creationDate = creationDate; - this.baselineName = baselineName; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public Date getCreationDate() { - return creationDate; - } - - public void setCreationDate(Date creationDate) { - this.creationDate = creationDate; - } - - public String getBaselineName() { - return baselineName; - } - - public void setBaselineName(String baselineName) { - this.baselineName = baselineName; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof Baseline)) { - return false; - } - Baseline other = (Baseline) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Baseline[ id=" + id + " ]"; - } - - /** - * @return the description - */ - public String getDescription() { - return description; - } - - /** - * @param description the description to set - */ - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getHistoryList() { - return historyList; - } - - public void setHistoryList(List historyList) { - this.historyList = historyList; - } - - public RequirementSpec getRequirementSpec() { - return requirementSpec; - } - - public void setRequirementSpec(RequirementSpec requirementSpec) { - this.requirementSpec = requirementSpec; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.Date; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinColumns; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "baseline") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Baseline.findAll", + query = "SELECT b FROM Baseline b") + , @NamedQuery(name = "Baseline.findById", + query = "SELECT b FROM Baseline b WHERE b.id = :id") + , @NamedQuery(name = "Baseline.findByCreationDate", + query = "SELECT b FROM Baseline b WHERE b.creationDate = :creationDate") + , @NamedQuery(name = "Baseline.findByBaselineName", + query = "SELECT b FROM Baseline b WHERE b.baselineName = :baselineName")}) +public class Baseline implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @NotNull + @Column(name = "id") + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "Baseline_IDGEN") + @TableGenerator(name = "Baseline_IDGEN", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "baseline", + initialValue = 1, + allocationSize = 1) + private Integer id; + @Basic(optional = false) + @NotNull + @Column(name = "creation_date") + @Temporal(TemporalType.TIMESTAMP) + private Date creationDate; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "baseline_name") + private String baselineName; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "description") + private String description; + @JoinTable(name = "baseline_has_history", joinColumns = { + @JoinColumn(name = "baseline_id", referencedColumnName = "id")}, inverseJoinColumns = { + @JoinColumn(name = "history_id", referencedColumnName = "id")}) + @ManyToMany + private List historyList; + @JoinColumns({ + @JoinColumn(name = "requirement_spec_id", referencedColumnName = "id") + , @JoinColumn(name = "requirement_spec_project_id", referencedColumnName = "project_id") + , @JoinColumn(name = "requirement_spec_spec_level_id", referencedColumnName = "spec_level_id")}) + @ManyToOne(optional = false) + private RequirementSpec requirementSpec; + + public Baseline() { + } + + public Baseline(Date creationDate, String baselineName) { + this.creationDate = creationDate; + this.baselineName = baselineName; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public Date getCreationDate() { + return creationDate; + } + + public void setCreationDate(Date creationDate) { + this.creationDate = creationDate; + } + + public String getBaselineName() { + return baselineName; + } + + public void setBaselineName(String baselineName) { + this.baselineName = baselineName; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof Baseline)) { + return false; + } + Baseline other = (Baseline) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Baseline[ id=" + id + " ]"; + } + + /** + * @return the description + */ + public String getDescription() { + return description; + } + + /** + * @param description the description to set + */ + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getHistoryList() { + return historyList; + } + + public void setHistoryList(List historyList) { + this.historyList = historyList; + } + + public RequirementSpec getRequirementSpec() { + return requirementSpec; + } + + public void setRequirementSpec(RequirementSpec requirementSpec) { + this.requirementSpec = requirementSpec; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Cause.java b/VM-Core/src/main/java/com/validation/manager/core/db/Cause.java index d3bd4036..6b99ceb7 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Cause.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Cause.java @@ -13,140 +13,140 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "cause") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Cause.findAll", - query = "SELECT c FROM Cause c") - , @NamedQuery(name = "Cause.findById", - query = "SELECT c FROM Cause c WHERE c.id = :id") - , @NamedQuery(name = "Cause.findByName", - query = "SELECT c FROM Cause c WHERE c.name = :name")}) -public class Cause implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, generator = "CauseGen") - @TableGenerator(name = "CauseGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "cause", - allocationSize = 1, - initialValue = 1000) - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Basic(optional = false) - @NotNull - @Lob - @Size(min = 1, max = 65535) - @Column(name = "description") - private String description; - @JoinTable(name = "risk_item_has_cause", joinColumns = { - @JoinColumn(name = "cause_id", referencedColumnName = "id")}, - inverseJoinColumns = { - @JoinColumn(name = "risk_item_id", referencedColumnName = "id") - , @JoinColumn(name = "risk_item_FMEA_id", - referencedColumnName = "FMEA_id")}) - @ManyToMany - private List riskItemList; - - public Cause() { - } - - public Cause(String name, String description) { - this.name = name; - this.description = description; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getRiskItemList() { - return riskItemList; - } - - public void setRiskItemList(List riskItemList) { - this.riskItemList = riskItemList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof Cause)) { - return false; - } - Cause other = (Cause) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Cause[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "cause") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Cause.findAll", + query = "SELECT c FROM Cause c") + , @NamedQuery(name = "Cause.findById", + query = "SELECT c FROM Cause c WHERE c.id = :id") + , @NamedQuery(name = "Cause.findByName", + query = "SELECT c FROM Cause c WHERE c.name = :name")}) +public class Cause implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, generator = "CauseGen") + @TableGenerator(name = "CauseGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "cause", + allocationSize = 1, + initialValue = 1_000) + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Basic(optional = false) + @NotNull + @Lob + @Size(min = 1, max = 65_535) + @Column(name = "description") + private String description; + @JoinTable(name = "risk_item_has_cause", joinColumns = { + @JoinColumn(name = "cause_id", referencedColumnName = "id")}, + inverseJoinColumns = { + @JoinColumn(name = "risk_item_id", referencedColumnName = "id") + , @JoinColumn(name = "risk_item_FMEA_id", + referencedColumnName = "FMEA_id")}) + @ManyToMany + private List riskItemList; + + public Cause() { + } + + public Cause(String name, String description) { + this.name = name; + this.description = description; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getRiskItemList() { + return riskItemList; + } + + public void setRiskItemList(List riskItemList) { + this.riskItemList = riskItemList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof Cause)) { + return false; + } + Cause other = (Cause) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Cause[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/CorrectiveAction.java b/VM-Core/src/main/java/com/validation/manager/core/db/CorrectiveAction.java index 9baeffe3..62860b2c 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/CorrectiveAction.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/CorrectiveAction.java @@ -13,137 +13,137 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "corrective_action") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "CorrectiveAction.findAll", - query = "SELECT c FROM CorrectiveAction c") - , @NamedQuery(name = "CorrectiveAction.findById", - query = "SELECT c FROM CorrectiveAction c WHERE c.id = :id")}) -public class CorrectiveAction implements Serializable { - - @OneToMany(cascade = CascadeType.ALL, mappedBy = "correctiveAction") - private List exceptionHasCorrectiveActionList; - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, generator = "CAGen") - @TableGenerator(name = "CAGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "corrective_action", - allocationSize = 1, - initialValue = 1000) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Lob - @Size(min = 1, max = 65535) - @Column(name = "details") - private String details; - @JoinTable(name = "user_has_corrective_action", joinColumns = { - @JoinColumn(name = "corrective_action_id", - referencedColumnName = "id")}, inverseJoinColumns = { - @JoinColumn(name = "user_id", referencedColumnName = "id")}) - @ManyToMany - private List vmUserList; - - public CorrectiveAction() { - } - - public CorrectiveAction(String details) { - this.details = details; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getDetails() { - return details; - } - - public void setDetails(String details) { - this.details = details; - } - - @XmlTransient - @JsonIgnore - public List getVmUserList() { - return vmUserList; - } - - public void setVmUserList(List vmUserList) { - this.vmUserList = vmUserList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof CorrectiveAction)) { - return false; - } - CorrectiveAction other = (CorrectiveAction) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.CorrectiveAction[ id=" + id + " ]"; - } - - @XmlTransient - @JsonIgnore - public List getExceptionHasCorrectiveActionList() { - return exceptionHasCorrectiveActionList; - } - - public void setExceptionHasCorrectiveActionList(List exceptionHasCorrectiveActionList) { - this.exceptionHasCorrectiveActionList = exceptionHasCorrectiveActionList; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "corrective_action") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "CorrectiveAction.findAll", + query = "SELECT c FROM CorrectiveAction c") + , @NamedQuery(name = "CorrectiveAction.findById", + query = "SELECT c FROM CorrectiveAction c WHERE c.id = :id")}) +public class CorrectiveAction implements Serializable { + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "correctiveAction") + private List exceptionHasCorrectiveActionList; + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, generator = "CAGen") + @TableGenerator(name = "CAGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "corrective_action", + allocationSize = 1, + initialValue = 1_000) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Lob + @Size(min = 1, max = 65_535) + @Column(name = "details") + private String details; + @JoinTable(name = "user_has_corrective_action", joinColumns = { + @JoinColumn(name = "corrective_action_id", + referencedColumnName = "id")}, inverseJoinColumns = { + @JoinColumn(name = "user_id", referencedColumnName = "id")}) + @ManyToMany + private List vmUserList; + + public CorrectiveAction() { + } + + public CorrectiveAction(String details) { + this.details = details; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getDetails() { + return details; + } + + public void setDetails(String details) { + this.details = details; + } + + @XmlTransient + @JsonIgnore + public List getVmUserList() { + return vmUserList; + } + + public void setVmUserList(List vmUserList) { + this.vmUserList = vmUserList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof CorrectiveAction)) { + return false; + } + CorrectiveAction other = (CorrectiveAction) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.CorrectiveAction[ id=" + id + " ]"; + } + + @XmlTransient + @JsonIgnore + public List getExceptionHasCorrectiveActionList() { + return exceptionHasCorrectiveActionList; + } + + public void setExceptionHasCorrectiveActionList(List exceptionHasCorrectiveActionList) { + this.exceptionHasCorrectiveActionList = exceptionHasCorrectiveActionList; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/ExecutionResult.java b/VM-Core/src/main/java/com/validation/manager/core/db/ExecutionResult.java index 0e22e234..55f3e4e6 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/ExecutionResult.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/ExecutionResult.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,123 +13,118 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "execution_result") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "ExecutionResult.findAll", - query = "SELECT e FROM ExecutionResult e") - , @NamedQuery(name = "ExecutionResult.findById", - query = "SELECT e FROM ExecutionResult e WHERE e.id = :id") - , @NamedQuery(name = "ExecutionResult.findByResultName", - query = "SELECT e FROM ExecutionResult e WHERE e.resultName = :resultName")}) -public class ExecutionResult implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @NotNull - @Column(name = "id") - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "ExecutionResult_IDGEN") - @TableGenerator(name = "ExecutionResult_IDGEN", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "execution_result", - initialValue = 1, - allocationSize = 1) - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "result_name") - private String resultName; - @OneToMany(mappedBy = "resultId") - private List executionStepList; - - public ExecutionResult() { - } - - public ExecutionResult(Integer id) { - this.id = id; - } - - public ExecutionResult(Integer id, String resultName) { - this.id = id; - this.resultName = resultName; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getResultName() { - return resultName; - } - - public void setResultName(String resultName) { - this.resultName = resultName; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepList() { - return executionStepList; - } - - public void setExecutionStepList(List executionStepList) { - this.executionStepList = executionStepList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof ExecutionResult)) { - return false; - } - ExecutionResult other = (ExecutionResult) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.ExecutionResult[ id=" + id + " ]"; - } - -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "execution_result") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "ExecutionResult.findAll", + query = "SELECT e FROM ExecutionResult e") + , @NamedQuery(name = "ExecutionResult.findById", + query = "SELECT e FROM ExecutionResult e WHERE e.id = :id") + , @NamedQuery(name = "ExecutionResult.findByResultName", + query = "SELECT e FROM ExecutionResult e WHERE e.resultName = :resultName")}) +public class ExecutionResult implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @NotNull + @Column(name = "id") + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "ExecutionResult_IDGEN") + @TableGenerator(name = "ExecutionResult_IDGEN", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "execution_result", + initialValue = 1, + allocationSize = 1) + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "result_name") + private String resultName; + @OneToMany(mappedBy = "resultId") + private List executionStepList; + + public ExecutionResult() { + } + + public ExecutionResult(String resultName) { + this.resultName = resultName; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getResultName() { + return resultName; + } + + public void setResultName(String resultName) { + this.resultName = resultName; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepList() { + return executionStepList; + } + + public void setExecutionStepList(List executionStepList) { + this.executionStepList = executionStepList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof ExecutionResult)) { + return false; + } + ExecutionResult other = (ExecutionResult) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.ExecutionResult[ id=" + id + " ]"; + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/ExecutionStep.java b/VM-Core/src/main/java/com/validation/manager/core/db/ExecutionStep.java index 7d83e548..f3570a21 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/ExecutionStep.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/ExecutionStep.java @@ -13,365 +13,365 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.Date; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.EmbeddedId; -import javax.persistence.Entity; -import javax.persistence.JoinColumn; -import javax.persistence.JoinColumns; -import javax.persistence.JoinTable; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "execution_step") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "ExecutionStep.findAll", - query = "SELECT e FROM ExecutionStep e") - , @NamedQuery(name = "ExecutionStep.findByTestCaseExecutionId", - query = "SELECT e FROM ExecutionStep e WHERE e.executionStepPK.testCaseExecutionId = :testCaseExecutionId") - , @NamedQuery(name = "ExecutionStep.findByStepId", - query = "SELECT e FROM ExecutionStep e WHERE e.executionStepPK.stepId = :stepId") - , @NamedQuery(name = "ExecutionStep.findByStepTestCaseId", - query = "SELECT e FROM ExecutionStep e WHERE e.executionStepPK.stepTestCaseId = :stepTestCaseId") - , @NamedQuery(name = "ExecutionStep.findByExecutionTime", - query = "SELECT e FROM ExecutionStep e WHERE e.executionTime = :executionTime") - , @NamedQuery(name = "ExecutionStep.findByExecutionStart", - query = "SELECT e FROM ExecutionStep e WHERE e.executionStart = :executionStart") - , @NamedQuery(name = "ExecutionStep.findByExecutionEnd", - query = "SELECT e FROM ExecutionStep e WHERE e.executionEnd = :executionEnd") - , @NamedQuery(name = "ExecutionStep.findByAssignedTime", - query = "SELECT e FROM ExecutionStep e WHERE e.assignedTime = :assignedTime") - , @NamedQuery(name = "ExecutionStep.findByLocked", - query = "SELECT e FROM ExecutionStep e WHERE e.locked = :locked") - , @NamedQuery(name = "ExecutionStep.findByReviewed", - query = "SELECT e FROM ExecutionStep e WHERE e.reviewed = :reviewed")}) -public class ExecutionStep implements Serializable { - - private static final long serialVersionUID = 1L; - @EmbeddedId - protected ExecutionStepPK executionStepPK; - // @Max(value=?) @Min(value=?)//if you know range of your decimal fields consider using these annotations to enforce field validation - @Column(name = "execution_time") - private Double executionTime; - @Lob - @Size(max = 2147483647) - @Column(name = "comment") - private String comment; - @Column(name = "execution_start") - @Temporal(TemporalType.TIMESTAMP) - private Date executionStart; - @Column(name = "execution_end") - @Temporal(TemporalType.TIMESTAMP) - private Date executionEnd; - @Column(name = "review_date") - @Temporal(TemporalType.TIMESTAMP) - private Date reviewDate; - @Column(name = "assigned_time") - @Temporal(TemporalType.TIMESTAMP) - private Date assignedTime; - @Basic(optional = false) - @NotNull - @Column(name = "locked") - private boolean locked; - @Basic(optional = false) - @NotNull - @Column(name = "reviewed") - private boolean reviewed; - @JoinColumn(name = "result_id", referencedColumnName = "id") - @ManyToOne - private ExecutionResult resultId; - @JoinColumn(name = "review_result_id", referencedColumnName = "id") - @ManyToOne - private ReviewResult reviewResultId; - @JoinColumn(name = "assignee", referencedColumnName = "id") - @ManyToOne - private VmUser assignee; - @JoinColumn(name = "assigner", referencedColumnName = "id") - @ManyToOne - private VmUser assigner; - @JoinColumn(name = "reviewer", referencedColumnName = "id") - @ManyToOne - private VmUser reviewer; - @JoinColumns({ - @JoinColumn(name = "step_id", referencedColumnName = "id", - insertable = false, updatable = false) - , @JoinColumn(name = "step_test_case_id", - referencedColumnName = "test_case_id", insertable = false, - updatable = false)}) - @ManyToOne(optional = false) - private Step step; - @JoinColumn(name = "test_case_execution_id", referencedColumnName = "id", - insertable = false, updatable = false) - @ManyToOne(optional = false) - private TestCaseExecution testCaseExecution; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "executionStep") - private List executionStepHasAttachmentList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "executionStep") - private List executionStepHasIssueList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "executionStep") - private List executionStepHasVmUserList; - @JoinTable(name = "execution_step_has_history", joinColumns = { - @JoinColumn(name = "execution_step_test_case_execution_id", referencedColumnName = "test_case_execution_id") - , @JoinColumn(name = "execution_step_step_id", referencedColumnName = "step_id") - , @JoinColumn(name = "execution_step_step_test_case_id", referencedColumnName = "step_test_case_id")}, inverseJoinColumns = { - @JoinColumn(name = "history_id", referencedColumnName = "id")}) - @ManyToMany - private List historyList; - @JoinColumn(name = "step_history", referencedColumnName = "id") - @ManyToOne(optional = false) - private History stepHistory; - - public ExecutionStep() { - } - - public ExecutionStep(ExecutionStepPK executionStepPK) { - this.executionStepPK = executionStepPK; - } - - public ExecutionStep(ExecutionStepPK executionStepPK, boolean locked, boolean reviewed) { - this.executionStepPK = executionStepPK; - this.locked = locked; - this.reviewed = reviewed; - } - - public ExecutionStep(int testCaseExecutionId, int stepId, int stepTestCaseId) { - this.executionStepPK = new ExecutionStepPK(testCaseExecutionId, - stepId, stepTestCaseId); - } - - public ExecutionStepPK getExecutionStepPK() { - return executionStepPK; - } - - public void setExecutionStepPK(ExecutionStepPK executionStepPK) { - this.executionStepPK = executionStepPK; - } - - public Double getExecutionTime() { - return executionTime; - } - - public void setExecutionTime(Double executionTime) { - this.executionTime = executionTime; - } - - public String getComment() { - return comment; - } - - public void setComment(String comment) { - this.comment = comment; - } - - public Date getExecutionStart() { - return executionStart; - } - - public void setExecutionStart(Date executionStart) { - this.executionStart = executionStart; - } - - public Date getExecutionEnd() { - return executionEnd; - } - - public void setExecutionEnd(Date executionEnd) { - this.executionEnd = executionEnd; - } - - public Date getAssignedTime() { - return assignedTime; - } - - public void setAssignedTime(Date assignedTime) { - this.assignedTime = assignedTime; - } - - public boolean getLocked() { - return locked; - } - - public void setLocked(boolean locked) { - this.locked = locked; - } - - public boolean getReviewed() { - return reviewed; - } - - public void setReviewed(boolean reviewed) { - this.reviewed = reviewed; - } - - public ExecutionResult getResultId() { - return resultId; - } - - public void setResultId(ExecutionResult resultId) { - this.resultId = resultId; - } - - public ReviewResult getReviewResultId() { - return reviewResultId; - } - - public void setReviewResultId(ReviewResult reviewResultId) { - this.reviewResultId = reviewResultId; - } - - public VmUser getAssignee() { - return assignee; - } - - public void setAssignee(VmUser assignee) { - this.assignee = assignee; - } - - public VmUser getAssigner() { - return assigner; - } - - public void setAssigner(VmUser assigner) { - this.assigner = assigner; - } - - public Step getStep() { - return step; - } - - public void setStep(Step step) { - this.step = step; - } - - public TestCaseExecution getTestCaseExecution() { - return testCaseExecution; - } - - public void setTestCaseExecution(TestCaseExecution testCaseExecution) { - this.testCaseExecution = testCaseExecution; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepHasAttachmentList() { - return executionStepHasAttachmentList; - } - - public void setExecutionStepHasAttachmentList(List executionStepHasAttachmentList) { - this.executionStepHasAttachmentList = executionStepHasAttachmentList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (executionStepPK != null ? executionStepPK.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof ExecutionStep)) { - return false; - } - ExecutionStep other = (ExecutionStep) object; - return !((this.executionStepPK == null && other.executionStepPK != null) - || (this.executionStepPK != null - && !this.executionStepPK.equals(other.executionStepPK))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.ExecutionStep[ executionStepPK=" + executionStepPK + " ]"; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepHasIssueList() { - return executionStepHasIssueList; - } - - public void setExecutionStepHasIssueList(List executionStepHasIssueList) { - this.executionStepHasIssueList = executionStepHasIssueList; - } - - /** - * @return the reviewDate - */ - public Date getReviewDate() { - return reviewDate; - } - - /** - * @param reviewDate the reviewDate to set - */ - public void setReviewDate(Date reviewDate) { - this.reviewDate = reviewDate; - } - - /** - * @return the reviewer - */ - public VmUser getReviewer() { - return reviewer; - } - - /** - * @param reviewer the reviewer to set - */ - public void setReviewer(VmUser reviewer) { - this.reviewer = reviewer; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepHasVmUserList() { - return executionStepHasVmUserList; - } - - public void setExecutionStepHasVmUserList(List executionStepHasVmUserList) { - this.executionStepHasVmUserList = executionStepHasVmUserList; - } - - @XmlTransient - @JsonIgnore - public List getHistoryList() { - return historyList; - } - - public void setHistoryList(List historyList) { - this.historyList = historyList; - } - - public History getStepHistory() { - return stepHistory; - } - - public void setStepHistory(History stepHistory) { - this.stepHistory = stepHistory; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.Date; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.JoinColumns; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "execution_step") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "ExecutionStep.findAll", + query = "SELECT e FROM ExecutionStep e") + , @NamedQuery(name = "ExecutionStep.findByTestCaseExecutionId", + query = "SELECT e FROM ExecutionStep e WHERE e.executionStepPK.testCaseExecutionId = :testCaseExecutionId") + , @NamedQuery(name = "ExecutionStep.findByStepId", + query = "SELECT e FROM ExecutionStep e WHERE e.executionStepPK.stepId = :stepId") + , @NamedQuery(name = "ExecutionStep.findByStepTestCaseId", + query = "SELECT e FROM ExecutionStep e WHERE e.executionStepPK.stepTestCaseId = :stepTestCaseId") + , @NamedQuery(name = "ExecutionStep.findByExecutionTime", + query = "SELECT e FROM ExecutionStep e WHERE e.executionTime = :executionTime") + , @NamedQuery(name = "ExecutionStep.findByExecutionStart", + query = "SELECT e FROM ExecutionStep e WHERE e.executionStart = :executionStart") + , @NamedQuery(name = "ExecutionStep.findByExecutionEnd", + query = "SELECT e FROM ExecutionStep e WHERE e.executionEnd = :executionEnd") + , @NamedQuery(name = "ExecutionStep.findByAssignedTime", + query = "SELECT e FROM ExecutionStep e WHERE e.assignedTime = :assignedTime") + , @NamedQuery(name = "ExecutionStep.findByLocked", + query = "SELECT e FROM ExecutionStep e WHERE e.locked = :locked") + , @NamedQuery(name = "ExecutionStep.findByReviewed", + query = "SELECT e FROM ExecutionStep e WHERE e.reviewed = :reviewed")}) +public class ExecutionStep implements Serializable { + + private static final long serialVersionUID = 1L; + @EmbeddedId + protected ExecutionStepPK executionStepPK; + // @Max(value=?) @Min(value=?)//if you know range of your decimal fields consider using these annotations to enforce field validation + @Column(name = "execution_time") + private Double executionTime; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "comment") + private String comment; + @Column(name = "execution_start") + @Temporal(TemporalType.TIMESTAMP) + private Date executionStart; + @Column(name = "execution_end") + @Temporal(TemporalType.TIMESTAMP) + private Date executionEnd; + @Column(name = "review_date") + @Temporal(TemporalType.TIMESTAMP) + private Date reviewDate; + @Column(name = "assigned_time") + @Temporal(TemporalType.TIMESTAMP) + private Date assignedTime; + @Basic(optional = false) + @NotNull + @Column(name = "locked") + private boolean locked; + @Basic(optional = false) + @NotNull + @Column(name = "reviewed") + private boolean reviewed; + @JoinColumn(name = "result_id", referencedColumnName = "id") + @ManyToOne + private ExecutionResult resultId; + @JoinColumn(name = "review_result_id", referencedColumnName = "id") + @ManyToOne + private ReviewResult reviewResultId; + @JoinColumn(name = "assignee", referencedColumnName = "id") + @ManyToOne + private VmUser assignee; + @JoinColumn(name = "assigner", referencedColumnName = "id") + @ManyToOne + private VmUser assigner; + @JoinColumn(name = "reviewer", referencedColumnName = "id") + @ManyToOne + private VmUser reviewer; + @JoinColumns({ + @JoinColumn(name = "step_id", referencedColumnName = "id", + insertable = false, updatable = false) + , @JoinColumn(name = "step_test_case_id", + referencedColumnName = "test_case_id", insertable = false, + updatable = false)}) + @ManyToOne(optional = false) + private Step step; + @JoinColumn(name = "test_case_execution_id", referencedColumnName = "id", + insertable = false, updatable = false) + @ManyToOne(optional = false) + private TestCaseExecution testCaseExecution; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "executionStep") + private List executionStepHasAttachmentList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "executionStep") + private List executionStepHasIssueList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "executionStep") + private List executionStepHasVmUserList; + @JoinTable(name = "execution_step_has_history", joinColumns = { + @JoinColumn(name = "execution_step_test_case_execution_id", referencedColumnName = "test_case_execution_id") + , @JoinColumn(name = "execution_step_step_id", referencedColumnName = "step_id") + , @JoinColumn(name = "execution_step_step_test_case_id", referencedColumnName = "step_test_case_id")}, inverseJoinColumns = { + @JoinColumn(name = "history_id", referencedColumnName = "id")}) + @ManyToMany + private List historyList; + @JoinColumn(name = "step_history", referencedColumnName = "id") + @ManyToOne(optional = false) + private History stepHistory; + + public ExecutionStep() { + } + + public ExecutionStep(ExecutionStepPK executionStepPK) { + this.executionStepPK = executionStepPK; + } + + public ExecutionStep(ExecutionStepPK executionStepPK, boolean locked, boolean reviewed) { + this.executionStepPK = executionStepPK; + this.locked = locked; + this.reviewed = reviewed; + } + + public ExecutionStep(int testCaseExecutionId, int stepId, int stepTestCaseId) { + this.executionStepPK = new ExecutionStepPK(testCaseExecutionId, + stepId, stepTestCaseId); + } + + public ExecutionStepPK getExecutionStepPK() { + return executionStepPK; + } + + public void setExecutionStepPK(ExecutionStepPK executionStepPK) { + this.executionStepPK = executionStepPK; + } + + public Double getExecutionTime() { + return executionTime; + } + + public void setExecutionTime(Double executionTime) { + this.executionTime = executionTime; + } + + public String getComment() { + return comment; + } + + public void setComment(String comment) { + this.comment = comment; + } + + public Date getExecutionStart() { + return executionStart; + } + + public void setExecutionStart(Date executionStart) { + this.executionStart = executionStart; + } + + public Date getExecutionEnd() { + return executionEnd; + } + + public void setExecutionEnd(Date executionEnd) { + this.executionEnd = executionEnd; + } + + public Date getAssignedTime() { + return assignedTime; + } + + public void setAssignedTime(Date assignedTime) { + this.assignedTime = assignedTime; + } + + public boolean getLocked() { + return locked; + } + + public void setLocked(boolean locked) { + this.locked = locked; + } + + public boolean getReviewed() { + return reviewed; + } + + public void setReviewed(boolean reviewed) { + this.reviewed = reviewed; + } + + public ExecutionResult getResultId() { + return resultId; + } + + public void setResultId(ExecutionResult resultId) { + this.resultId = resultId; + } + + public ReviewResult getReviewResultId() { + return reviewResultId; + } + + public void setReviewResultId(ReviewResult reviewResultId) { + this.reviewResultId = reviewResultId; + } + + public VmUser getAssignee() { + return assignee; + } + + public void setAssignee(VmUser assignee) { + this.assignee = assignee; + } + + public VmUser getAssigner() { + return assigner; + } + + public void setAssigner(VmUser assigner) { + this.assigner = assigner; + } + + public Step getStep() { + return step; + } + + public void setStep(Step step) { + this.step = step; + } + + public TestCaseExecution getTestCaseExecution() { + return testCaseExecution; + } + + public void setTestCaseExecution(TestCaseExecution testCaseExecution) { + this.testCaseExecution = testCaseExecution; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepHasAttachmentList() { + return executionStepHasAttachmentList; + } + + public void setExecutionStepHasAttachmentList(List executionStepHasAttachmentList) { + this.executionStepHasAttachmentList = executionStepHasAttachmentList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (executionStepPK != null ? executionStepPK.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof ExecutionStep)) { + return false; + } + ExecutionStep other = (ExecutionStep) object; + return !((this.executionStepPK == null && other.executionStepPK != null) + || (this.executionStepPK != null + && !this.executionStepPK.equals(other.executionStepPK))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.ExecutionStep[ executionStepPK=" + executionStepPK + " ]"; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepHasIssueList() { + return executionStepHasIssueList; + } + + public void setExecutionStepHasIssueList(List executionStepHasIssueList) { + this.executionStepHasIssueList = executionStepHasIssueList; + } + + /** + * @return the reviewDate + */ + public Date getReviewDate() { + return reviewDate; + } + + /** + * @param reviewDate the reviewDate to set + */ + public void setReviewDate(Date reviewDate) { + this.reviewDate = reviewDate; + } + + /** + * @return the reviewer + */ + public VmUser getReviewer() { + return reviewer; + } + + /** + * @param reviewer the reviewer to set + */ + public void setReviewer(VmUser reviewer) { + this.reviewer = reviewer; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepHasVmUserList() { + return executionStepHasVmUserList; + } + + public void setExecutionStepHasVmUserList(List executionStepHasVmUserList) { + this.executionStepHasVmUserList = executionStepHasVmUserList; + } + + @XmlTransient + @JsonIgnore + public List getHistoryList() { + return historyList; + } + + public void setHistoryList(List historyList) { + this.historyList = historyList; + } + + public History getStepHistory() { + return stepHistory; + } + + public void setStepHistory(History stepHistory) { + this.stepHistory = stepHistory; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/FailureMode.java b/VM-Core/src/main/java/com/validation/manager/core/db/FailureMode.java index 0da6dbee..4b1714cd 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/FailureMode.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/FailureMode.java @@ -13,140 +13,140 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "failure_mode") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "FailureMode.findAll", - query = "SELECT f FROM FailureMode f") - , @NamedQuery(name = "FailureMode.findById", - query = "SELECT f FROM FailureMode f WHERE f.id = :id") - , @NamedQuery(name = "FailureMode.findByName", - query = "SELECT f FROM FailureMode f WHERE f.name = :name")}) -public class FailureMode implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @GeneratedValue(strategy = GenerationType.TABLE, generator = "FMGen") - @TableGenerator(name = "FMGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "failure_mode", - allocationSize = 1, - initialValue = 1000) - @Basic(optional = false) - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Basic(optional = false) - @NotNull - @Lob - @Size(min = 1, max = 65535) - @Column(name = "description") - private String description; - @JoinTable(name = "risk_item_has_failure_mode", joinColumns = { - @JoinColumn(name = "failure_mode_id", referencedColumnName = "id")}, - inverseJoinColumns = { - @JoinColumn(name = "risk_item_id", referencedColumnName = "id") - , @JoinColumn(name = "risk_item_FMEA_id", - referencedColumnName = "FMEA_id")}) - @ManyToMany - private List riskItemList; - - public FailureMode() { - } - - public FailureMode(String name, String description) { - this.name = name; - this.description = description; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getRiskItemList() { - return riskItemList; - } - - public void setRiskItemList(List riskItemList) { - this.riskItemList = riskItemList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof FailureMode)) { - return false; - } - FailureMode other = (FailureMode) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.FailureMode[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "failure_mode") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "FailureMode.findAll", + query = "SELECT f FROM FailureMode f") + , @NamedQuery(name = "FailureMode.findById", + query = "SELECT f FROM FailureMode f WHERE f.id = :id") + , @NamedQuery(name = "FailureMode.findByName", + query = "SELECT f FROM FailureMode f WHERE f.name = :name")}) +public class FailureMode implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @GeneratedValue(strategy = GenerationType.TABLE, generator = "FMGen") + @TableGenerator(name = "FMGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "failure_mode", + allocationSize = 1, + initialValue = 1_000) + @Basic(optional = false) + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Basic(optional = false) + @NotNull + @Lob + @Size(min = 1, max = 65_535) + @Column(name = "description") + private String description; + @JoinTable(name = "risk_item_has_failure_mode", joinColumns = { + @JoinColumn(name = "failure_mode_id", referencedColumnName = "id")}, + inverseJoinColumns = { + @JoinColumn(name = "risk_item_id", referencedColumnName = "id") + , @JoinColumn(name = "risk_item_FMEA_id", + referencedColumnName = "FMEA_id")}) + @ManyToMany + private List riskItemList; + + public FailureMode() { + } + + public FailureMode(String name, String description) { + this.name = name; + this.description = description; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getRiskItemList() { + return riskItemList; + } + + public void setRiskItemList(List riskItemList) { + this.riskItemList = riskItemList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof FailureMode)) { + return false; + } + FailureMode other = (FailureMode) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.FailureMode[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Fmea.java b/VM-Core/src/main/java/com/validation/manager/core/db/Fmea.java index edd94860..d0472f58 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Fmea.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Fmea.java @@ -13,172 +13,172 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.ManyToMany; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "fmea") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Fmea.findAll", query = "SELECT f FROM Fmea f") - , @NamedQuery(name = "Fmea.findById", query = "SELECT f FROM Fmea f " - + "WHERE f.id = :id") - , @NamedQuery(name = "Fmea.findByName", query = "SELECT f FROM Fmea f " - + "WHERE f.name = :name") - , @NamedQuery(name = "Fmea.findByDescription", query = "SELECT f FROM " - + "Fmea f WHERE f.description = :description")}) -public class Fmea implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @NotNull - @GeneratedValue(strategy = GenerationType.TABLE, generator = "FMEAGen") - @TableGenerator(name = "FMEAGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "fmea", - allocationSize = 1, - initialValue = 1000) - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 45) - @Column(name = "name") - private String name; - @Size(max = 45) - @Column(name = "description") - private String description; - @JoinTable(name = "fmea_has_risk_category", joinColumns = { - @JoinColumn(name = "FMEA_id", referencedColumnName = "id")}, - inverseJoinColumns = { - @JoinColumn(name = "risk_category_id", referencedColumnName = "id")}) - @ManyToMany - private List riskCategoryList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "fmea") - private List riskItemList; - @OneToMany(mappedBy = "parent") - private List fmeaList; - @JoinColumn(name = "parent", referencedColumnName = "id") - @ManyToOne - private Fmea parent; - - public Fmea() { - } - - public Fmea(String name) { - this.name = name; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getRiskCategoryList() { - return riskCategoryList; - } - - public void setRiskCategoryList(List riskCategoryList) { - this.riskCategoryList = riskCategoryList; - } - - @XmlTransient - @JsonIgnore - public List getRiskItemList() { - return riskItemList; - } - - public void setRiskItemList(List riskItemList) { - this.riskItemList = riskItemList; - } - - @XmlTransient - @JsonIgnore - public List getFmeaList() { - return fmeaList; - } - - public void setFmeaList(List fmeaList) { - this.fmeaList = fmeaList; - } - - public Fmea getParent() { - return parent; - } - - public void setParent(Fmea parent) { - this.parent = parent; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof Fmea)) { - return false; - } - Fmea other = (Fmea) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Fmea[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "fmea") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Fmea.findAll", query = "SELECT f FROM Fmea f") + , @NamedQuery(name = "Fmea.findById", query = "SELECT f FROM Fmea f " + + "WHERE f.id = :id") + , @NamedQuery(name = "Fmea.findByName", query = "SELECT f FROM Fmea f " + + "WHERE f.name = :name") + , @NamedQuery(name = "Fmea.findByDescription", query = "SELECT f FROM " + + "Fmea f WHERE f.description = :description")}) +public class Fmea implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @NotNull + @GeneratedValue(strategy = GenerationType.TABLE, generator = "FMEAGen") + @TableGenerator(name = "FMEAGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "fmea", + allocationSize = 1, + initialValue = 1_000) + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 45) + @Column(name = "name") + private String name; + @Size(max = 45) + @Column(name = "description") + private String description; + @JoinTable(name = "fmea_has_risk_category", joinColumns = { + @JoinColumn(name = "FMEA_id", referencedColumnName = "id")}, + inverseJoinColumns = { + @JoinColumn(name = "risk_category_id", referencedColumnName = "id")}) + @ManyToMany + private List riskCategoryList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "fmea") + private List riskItemList; + @OneToMany(mappedBy = "parent") + private List fmeaList; + @JoinColumn(name = "parent", referencedColumnName = "id") + @ManyToOne + private Fmea parent; + + public Fmea() { + } + + public Fmea(String name) { + this.name = name; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getRiskCategoryList() { + return riskCategoryList; + } + + public void setRiskCategoryList(List riskCategoryList) { + this.riskCategoryList = riskCategoryList; + } + + @XmlTransient + @JsonIgnore + public List getRiskItemList() { + return riskItemList; + } + + public void setRiskItemList(List riskItemList) { + this.riskItemList = riskItemList; + } + + @XmlTransient + @JsonIgnore + public List getFmeaList() { + return fmeaList; + } + + public void setFmeaList(List fmeaList) { + this.fmeaList = fmeaList; + } + + public Fmea getParent() { + return parent; + } + + public void setParent(Fmea parent) { + this.parent = parent; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof Fmea)) { + return false; + } + Fmea other = (Fmea) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Fmea[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Hazard.java b/VM-Core/src/main/java/com/validation/manager/core/db/Hazard.java index 0c94bfae..1ce93ed3 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Hazard.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Hazard.java @@ -13,141 +13,141 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "hazard") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Hazard.findAll", - query = "SELECT h FROM Hazard h") - , @NamedQuery(name = "Hazard.findById", - query = "SELECT h FROM Hazard h WHERE h.id = :id") - , @NamedQuery(name = "Hazard.findByName", - query = "SELECT h FROM Hazard h WHERE h.name = :name")}) -public class Hazard implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "HazardGen") - @TableGenerator(name = "HazardGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "hazard", - allocationSize = 1, - initialValue = 1000) - @Basic(optional = false) - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Basic(optional = false) - @NotNull - @Lob - @Size(min = 1, max = 65535) - @Column(name = "description") - private String description; - @JoinTable(name = "risk_item_has_hazard", joinColumns = { - @JoinColumn(name = "hazard_id", referencedColumnName = "id")}, - inverseJoinColumns = { - @JoinColumn(name = "risk_item_id", referencedColumnName = "id") - , @JoinColumn(name = "risk_item_FMEA_id", - referencedColumnName = "FMEA_id")}) - @ManyToMany - private List riskItemList; - - public Hazard() { - } - - public Hazard(String name, String description) { - this.name = name; - this.description = description; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getRiskItemList() { - return riskItemList; - } - - public void setRiskItemList(List riskItemList) { - this.riskItemList = riskItemList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof Hazard)) { - return false; - } - Hazard other = (Hazard) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Hazard[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "hazard") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Hazard.findAll", + query = "SELECT h FROM Hazard h") + , @NamedQuery(name = "Hazard.findById", + query = "SELECT h FROM Hazard h WHERE h.id = :id") + , @NamedQuery(name = "Hazard.findByName", + query = "SELECT h FROM Hazard h WHERE h.name = :name")}) +public class Hazard implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "HazardGen") + @TableGenerator(name = "HazardGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "hazard", + allocationSize = 1, + initialValue = 1_000) + @Basic(optional = false) + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Basic(optional = false) + @NotNull + @Lob + @Size(min = 1, max = 65_535) + @Column(name = "description") + private String description; + @JoinTable(name = "risk_item_has_hazard", joinColumns = { + @JoinColumn(name = "hazard_id", referencedColumnName = "id")}, + inverseJoinColumns = { + @JoinColumn(name = "risk_item_id", referencedColumnName = "id") + , @JoinColumn(name = "risk_item_FMEA_id", + referencedColumnName = "FMEA_id")}) + @ManyToMany + private List riskItemList; + + public Hazard() { + } + + public Hazard(String name, String description) { + this.name = name; + this.description = description; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getRiskItemList() { + return riskItemList; + } + + public void setRiskItemList(List riskItemList) { + this.riskItemList = riskItemList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof Hazard)) { + return false; + } + Hazard other = (Hazard) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Hazard[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/History.java b/VM-Core/src/main/java/com/validation/manager/core/db/History.java index ef7f7f15..b9e98349 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/History.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/History.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,287 +13,300 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.Date; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinColumns; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "history") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "History.findAll", - query = "SELECT h FROM History h") - , @NamedQuery(name = "History.findById", - query = "SELECT h FROM History h WHERE h.id = :id") - , @NamedQuery(name = "History.findByVersionMajor", - query = "SELECT h FROM History h WHERE h.versionMajor = :versionMajor") - , @NamedQuery(name = "History.findByVersionMid", - query = "SELECT h FROM History h WHERE h.versionMid = :versionMid") - , @NamedQuery(name = "History.findByVersionMinor", - query = "SELECT h FROM History h WHERE h.versionMinor = :versionMinor") - , @NamedQuery(name = "History.findByModificationTime", - query = "SELECT h FROM History h WHERE h.modificationTime = :modificationTime")}) -public class History implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "History_IDGEN") - @TableGenerator(name = "History_IDGEN", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "history", - initialValue = 1, - allocationSize = 1) - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Column(name = "version_major") - private int versionMajor = 0; - @Basic(optional = false) - @NotNull - @Column(name = "version_mid") - private int versionMid = 0; - @Basic(optional = false) - @NotNull - @Column(name = "version_minor") - private int versionMinor = 1; - @Basic(optional = false) - @NotNull - @Lob - @Size(min = 1, max = 2147483647) - @Column(name = "reason") - private String reason; - @Basic(optional = false) - @NotNull - @Column(name = "modification_time") - @Temporal(TemporalType.TIMESTAMP) - private Date modificationTime; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "history") - private List historyFieldList; - @JoinColumn(name = "modifier_id", referencedColumnName = "id") - @ManyToOne(optional = false) - private VmUser modifierId; - @ManyToMany(mappedBy = "historyList") - private List executionStepList; - @ManyToMany(mappedBy = "historyList") - private List baselineList; - @JoinColumn(name = "requirement_id", referencedColumnName = "id") - @ManyToOne(optional = true) - private Requirement requirementId; - @JoinColumn(name = "project_id", referencedColumnName = "id") - @ManyToOne(optional = false) - private Project projectId; - @JoinColumns({ - @JoinColumn(name = "step_id", referencedColumnName = "id") - , @JoinColumn(name = "step_test_case_id", - referencedColumnName = "test_case_id")}) - @ManyToOne(optional = false) - private Step step; - @JoinColumn(name = "vm_setting_id", referencedColumnName = "id") - @ManyToOne(optional = false) - private VmSetting vmSettingId; - - public History() { - } - - public History(Integer id) { - this.id = id; - } - - public History(Integer id, int versionMajor, int versionMid, - int versionMinor, String reason, Date modificationTime) { - this.id = id; - this.versionMajor = versionMajor; - this.versionMid = versionMid; - this.versionMinor = versionMinor; - this.reason = reason; - this.modificationTime = modificationTime; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public int getMajorVersion() { - return versionMajor; - } - - public void setMajorVersion(int versionMajor) { - this.versionMajor = versionMajor; - } - - public int getMidVersion() { - return versionMid; - } - - public void setMidVersion(int versionMid) { - this.versionMid = versionMid; - } - - public int getMinorVersion() { - return versionMinor; - } - - public void setMinorVersion(int versionMinor) { - this.versionMinor = versionMinor; - } - - public String getReason() { - return reason; - } - - public void setReason(String reason) { - this.reason = reason; - } - - public Date getModificationTime() { - return modificationTime; - } - - public void setModificationTime(Date modificationTime) { - this.modificationTime = modificationTime; - } - - @XmlTransient - @JsonIgnore - public List getHistoryFieldList() { - return historyFieldList; - } - - public void setHistoryFieldList(List historyFieldList) { - this.historyFieldList = historyFieldList; - } - - public VmUser getModifierId() { - return modifierId; - } - - public void setModifierId(VmUser modifierId) { - this.modifierId = modifierId; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof History)) { - return false; - } - History other = (History) object; - return !((this.id == null && other.id != null) || (this.id != null - && !this.id.equals(other.id))); - } - - @Override - public String toString() { - StringBuilder sb = new StringBuilder("Fields: "); - getHistoryFieldList().forEach(hf -> { - if (!sb.toString().isEmpty()) { - sb.append(", "); - } - sb.append(hf.getFieldName()) - .append("= ") - .append(hf.getFieldValue()); - }); - return "History{" + "id=" + id + ", versionMajor=" + versionMajor - + ", versionMid=" + versionMid + ", versionMinor=" - + versionMinor + ", reason=" + reason + ", modificationTime=" - + modificationTime + ", modifierId=" + modifierId - + "," + sb.toString() + '}'; - } - - @XmlTransient - @JsonIgnore - public List getBaselineList() { - return baselineList; - } - - public void setBaselineList(List baselineList) { - this.baselineList = baselineList; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepList() { - return executionStepList; - } - - public void setExecutionStepList(List executionStepList) { - this.executionStepList = executionStepList; - } - - public Requirement getRequirementId() { - return requirementId; - } - - public void setRequirementId(Requirement requirement) { - this.requirementId = requirement; - } - - public Project getProjectId() { - return projectId; - } - - public void setProjectId(Project projectId) { - this.projectId = projectId; - } - - public Step getStep() { - return step; - } - - public void setStep(Step step) { - this.step = step; - } - - public VmSetting getVmSettingId() { - return vmSettingId; - } - - public void setVmSettingId(VmSetting vmSettingId) { - this.vmSettingId = vmSettingId; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.Date; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinColumns; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "history") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "History.findAll", + query = "SELECT h FROM History h") + , @NamedQuery(name = "History.findById", + query = "SELECT h FROM History h WHERE h.id = :id") + , @NamedQuery(name = "History.findByVersionMajor", + query = "SELECT h FROM History h WHERE h.versionMajor = :versionMajor") + , @NamedQuery(name = "History.findByVersionMid", + query = "SELECT h FROM History h WHERE h.versionMid = :versionMid") + , @NamedQuery(name = "History.findByVersionMinor", + query = "SELECT h FROM History h WHERE h.versionMinor = :versionMinor") + , @NamedQuery(name = "History.findByModificationTime", + query = "SELECT h FROM History h WHERE h.modificationTime = :modificationTime")}) +public class History implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "History_IDGEN") + @TableGenerator(name = "History_IDGEN", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "history", + initialValue = 1, + allocationSize = 1) + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Column(name = "version_major") + private int versionMajor = 0; + @Basic(optional = false) + @NotNull + @Column(name = "version_mid") + private int versionMid = 0; + @Basic(optional = false) + @NotNull + @Column(name = "version_minor") + private int versionMinor = 1; + @Basic(optional = false) + @NotNull + @Lob + @Size(min = 1, max = 2_147_483_647) + @Column(name = "reason") + private String reason; + @Basic(optional = false) + @NotNull + @Column(name = "modification_time") + @Temporal(TemporalType.TIMESTAMP) + private Date modificationTime; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "history") + private List historyFieldList; + @JoinColumn(name = "modifier_id", referencedColumnName = "id") + @ManyToOne(optional = false) + private VmUser modifierId; + @ManyToMany(mappedBy = "historyList") + private List executionStepList; + @ManyToMany(mappedBy = "historyList") + private List baselineList; + @JoinColumn(name = "requirement_id", referencedColumnName = "id") + @ManyToOne(optional = true) + private Requirement requirementId; + @JoinColumn(name = "project_id", referencedColumnName = "id") + @ManyToOne(optional = false) + private Project projectId; + @JoinColumns({ + @JoinColumn(name = "step_id", referencedColumnName = "id") + , @JoinColumn(name = "step_test_case_id", + referencedColumnName = "test_case_id")}) + @ManyToOne(optional = false) + private Step step; + @JoinColumn(name = "vm_setting_id", referencedColumnName = "id") + @ManyToOne(optional = false) + private VmSetting vmSettingId; + @JoinColumn(name = "vm_user_id", referencedColumnName = "id") + @ManyToOne(optional = false) + private VmUser vmUserId; + + public History() { + } + + public History(Integer id) { + this.id = id; + } + + public History(Integer id, int versionMajor, int versionMid, + int versionMinor, String reason, Date modificationTime) { + this.id = id; + this.versionMajor = versionMajor; + this.versionMid = versionMid; + this.versionMinor = versionMinor; + this.reason = reason; + this.modificationTime = modificationTime; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public int getMajorVersion() { + return versionMajor; + } + + public void setMajorVersion(int versionMajor) { + this.versionMajor = versionMajor; + } + + public int getMidVersion() { + return versionMid; + } + + public void setMidVersion(int versionMid) { + this.versionMid = versionMid; + } + + public int getMinorVersion() { + return versionMinor; + } + + public void setMinorVersion(int versionMinor) { + this.versionMinor = versionMinor; + } + + public String getReason() { + return reason; + } + + public void setReason(String reason) { + this.reason = reason; + } + + public Date getModificationTime() { + return modificationTime; + } + + public void setModificationTime(Date modificationTime) { + this.modificationTime = modificationTime; + } + + @XmlTransient + @JsonIgnore + public List getHistoryFieldList() { + return historyFieldList; + } + + public void setHistoryFieldList(List historyFieldList) { + this.historyFieldList = historyFieldList; + } + + public VmUser getModifierId() { + return modifierId; + } + + public void setModifierId(VmUser modifierId) { + this.modifierId = modifierId; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof History)) { + return false; + } + History other = (History) object; + return !((this.id == null && other.id != null) || (this.id != null + && !this.id.equals(other.id))); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + getHistoryFieldList().forEach(hf -> { + if (sb.toString().isEmpty()) { + sb.append("Fields: "); + } else { + sb.append(", "); + } + sb.append(hf.getFieldName()) + .append("= ") + .append(hf.getFieldValue()); + }); + return "History{" + "id=" + id + ", versionMajor=" + versionMajor + + ", versionMid=" + versionMid + ", versionMinor=" + + versionMinor + ", reason=" + reason + ", modificationTime=" + + modificationTime + ", modifierId=" + modifierId + + "," + sb.toString() + '}'; + } + + @XmlTransient + @JsonIgnore + public List getBaselineList() { + return baselineList; + } + + public void setBaselineList(List baselineList) { + this.baselineList = baselineList; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepList() { + return executionStepList; + } + + public void setExecutionStepList(List executionStepList) { + this.executionStepList = executionStepList; + } + + public Requirement getRequirementId() { + return requirementId; + } + + public void setRequirementId(Requirement requirement) { + this.requirementId = requirement; + } + + public Project getProjectId() { + return projectId; + } + + public void setProjectId(Project projectId) { + this.projectId = projectId; + } + + public Step getStep() { + return step; + } + + public void setStep(Step step) { + this.step = step; + } + + public VmSetting getVmSettingId() { + return vmSettingId; + } + + public void setVmSettingId(VmSetting vmSettingId) { + this.vmSettingId = vmSettingId; + } + + public VmUser getVmUserId() { + return vmUserId; + } + + public void setVmUserId(VmUser vmUserId) { + this.vmUserId = vmUserId; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/HistoryField.java b/VM-Core/src/main/java/com/validation/manager/core/db/HistoryField.java index 684f2ea6..ca34b2f1 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/HistoryField.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/HistoryField.java @@ -13,146 +13,146 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.EmbeddedId; -import javax.persistence.Entity; -import javax.persistence.JoinColumn; -import javax.persistence.Lob; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.Table; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "history_field") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "HistoryField.findAll", - query = "SELECT h FROM HistoryField h") - , @NamedQuery(name = "HistoryField.findById", - query = "SELECT h FROM HistoryField h WHERE h.historyFieldPK.id = :id") - , @NamedQuery(name = "HistoryField.findByFieldTypeId", - query = "SELECT h FROM HistoryField h WHERE h.historyFieldPK.fieldTypeId = :fieldTypeId") - , @NamedQuery(name = "HistoryField.findByHistoryId", - query = "SELECT h FROM HistoryField h WHERE h.historyFieldPK.historyId = :historyId") - , @NamedQuery(name = "HistoryField.findByFieldName", - query = "SELECT h FROM HistoryField h WHERE h.fieldName = :fieldName")}) -public class HistoryField implements Serializable { - - private static final long serialVersionUID = 1L; - @EmbeddedId - protected HistoryFieldPK historyFieldPK; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 45) - @Column(name = "field_name") - private String fieldName; - @Basic(optional = false) - @NotNull - @Lob - @Size(min = 1, max = 2147483647) - @Column(name = "field_value") - private String fieldValue; - @JoinColumn(name = "field_type_id", referencedColumnName = "id", - insertable = false, updatable = false) - @ManyToOne(optional = false) - private FieldType fieldType; - @JoinColumn(name = "history_id", referencedColumnName = "id", - insertable = false, updatable = false) - @ManyToOne(optional = false) - private History history; - - public HistoryField() { - } - - public HistoryField(HistoryFieldPK historyFieldPK) { - this.historyFieldPK = historyFieldPK; - } - - public HistoryField(HistoryFieldPK historyFieldPK, String fieldName, - String fieldValue) { - this.historyFieldPK = historyFieldPK; - this.fieldName = fieldName; - this.fieldValue = fieldValue; - } - - public HistoryField(int fieldTypeId, int historyId) { - this.historyFieldPK = new HistoryFieldPK(fieldTypeId, historyId); - } - - public HistoryFieldPK getHistoryFieldPK() { - return historyFieldPK; - } - - public void setHistoryFieldPK(HistoryFieldPK historyFieldPK) { - this.historyFieldPK = historyFieldPK; - } - - public String getFieldName() { - return fieldName; - } - - public void setFieldName(String fieldName) { - this.fieldName = fieldName; - } - - public String getFieldValue() { - return fieldValue; - } - - public void setFieldValue(String fieldValue) { - this.fieldValue = fieldValue; - } - - public FieldType getFieldType() { - return fieldType; - } - - public void setFieldType(FieldType fieldType) { - this.fieldType = fieldType; - } - - public History getHistory() { - return history; - } - - public void setHistory(History history) { - this.history = history; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (historyFieldPK != null ? historyFieldPK.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof HistoryField)) { - return false; - } - HistoryField other = (HistoryField) object; - return !((this.historyFieldPK == null && other.historyFieldPK != null) - || (this.historyFieldPK != null - && !this.historyFieldPK.equals(other.historyFieldPK))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.HistoryField[ historyFieldPK=" - + historyFieldPK + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.Lob; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.Table; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "history_field") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "HistoryField.findAll", + query = "SELECT h FROM HistoryField h") + , @NamedQuery(name = "HistoryField.findById", + query = "SELECT h FROM HistoryField h WHERE h.historyFieldPK.id = :id") + , @NamedQuery(name = "HistoryField.findByFieldTypeId", + query = "SELECT h FROM HistoryField h WHERE h.historyFieldPK.fieldTypeId = :fieldTypeId") + , @NamedQuery(name = "HistoryField.findByHistoryId", + query = "SELECT h FROM HistoryField h WHERE h.historyFieldPK.historyId = :historyId") + , @NamedQuery(name = "HistoryField.findByFieldName", + query = "SELECT h FROM HistoryField h WHERE h.fieldName = :fieldName")}) +public class HistoryField implements Serializable { + + private static final long serialVersionUID = 1L; + @EmbeddedId + protected HistoryFieldPK historyFieldPK; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 45) + @Column(name = "field_name") + private String fieldName; + @Basic(optional = false) + @NotNull + @Lob + @Size(min = 1, max = 2_147_483_647) + @Column(name = "field_value") + private String fieldValue; + @JoinColumn(name = "field_type_id", referencedColumnName = "id", + insertable = false, updatable = false) + @ManyToOne(optional = false) + private FieldType fieldType; + @JoinColumn(name = "history_id", referencedColumnName = "id", + insertable = false, updatable = false) + @ManyToOne(optional = false) + private History history; + + public HistoryField() { + } + + public HistoryField(HistoryFieldPK historyFieldPK) { + this.historyFieldPK = historyFieldPK; + } + + public HistoryField(HistoryFieldPK historyFieldPK, String fieldName, + String fieldValue) { + this.historyFieldPK = historyFieldPK; + this.fieldName = fieldName; + this.fieldValue = fieldValue; + } + + public HistoryField(int fieldTypeId, int historyId) { + this.historyFieldPK = new HistoryFieldPK(fieldTypeId, historyId); + } + + public HistoryFieldPK getHistoryFieldPK() { + return historyFieldPK; + } + + public void setHistoryFieldPK(HistoryFieldPK historyFieldPK) { + this.historyFieldPK = historyFieldPK; + } + + public String getFieldName() { + return fieldName; + } + + public void setFieldName(String fieldName) { + this.fieldName = fieldName; + } + + public String getFieldValue() { + return fieldValue; + } + + public void setFieldValue(String fieldValue) { + this.fieldValue = fieldValue; + } + + public FieldType getFieldType() { + return fieldType; + } + + public void setFieldType(FieldType fieldType) { + this.fieldType = fieldType; + } + + public History getHistory() { + return history; + } + + public void setHistory(History history) { + this.history = history; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (historyFieldPK != null ? historyFieldPK.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof HistoryField)) { + return false; + } + HistoryField other = (HistoryField) object; + return !((this.historyFieldPK == null && other.historyFieldPK != null) + || (this.historyFieldPK != null + && !this.historyFieldPK.equals(other.historyFieldPK))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.HistoryField[ historyFieldPK=" + + historyFieldPK + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Investigation.java b/VM-Core/src/main/java/com/validation/manager/core/db/Investigation.java index 45d0a89f..7eb0c3c7 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Investigation.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Investigation.java @@ -13,130 +13,130 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.Lob; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "investigation") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Investigation.findAll", - query = "SELECT i FROM Investigation i") - , @NamedQuery(name = "Investigation.findById", - query = "SELECT i FROM Investigation i WHERE i.id = :id")}) -public class Investigation implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "InvestigationGen") - @TableGenerator(name = "InvestigationGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "investigation", - allocationSize = 1, - initialValue = 1000) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Lob - @Size(min = 1, max = 65535) - @Column(name = "description") - private String description; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "investigation") - private List userHasInvestigationList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "investigation") - private List exceptionHasInvestigationList; - - public Investigation() { - } - - public Investigation(String description) { - this.description = description; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getUserHasInvestigationList() { - return userHasInvestigationList; - } - - public void setUserHasInvestigationList(List userHasInvestigationList) { - this.userHasInvestigationList = userHasInvestigationList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof Investigation)) { - return false; - } - Investigation other = (Investigation) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Investigation[ id=" + id + " ]"; - } - - @XmlTransient - @JsonIgnore - public List getExceptionHasInvestigationList() { - return exceptionHasInvestigationList; - } - - public void setExceptionHasInvestigationList(List exceptionHasInvestigationList) { - this.exceptionHasInvestigationList = exceptionHasInvestigationList; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "investigation") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Investigation.findAll", + query = "SELECT i FROM Investigation i") + , @NamedQuery(name = "Investigation.findById", + query = "SELECT i FROM Investigation i WHERE i.id = :id")}) +public class Investigation implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "InvestigationGen") + @TableGenerator(name = "InvestigationGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "investigation", + allocationSize = 1, + initialValue = 1_000) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Lob + @Size(min = 1, max = 65_535) + @Column(name = "description") + private String description; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "investigation") + private List userHasInvestigationList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "investigation") + private List exceptionHasInvestigationList; + + public Investigation() { + } + + public Investigation(String description) { + this.description = description; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getUserHasInvestigationList() { + return userHasInvestigationList; + } + + public void setUserHasInvestigationList(List userHasInvestigationList) { + this.userHasInvestigationList = userHasInvestigationList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof Investigation)) { + return false; + } + Investigation other = (Investigation) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Investigation[ id=" + id + " ]"; + } + + @XmlTransient + @JsonIgnore + public List getExceptionHasInvestigationList() { + return exceptionHasInvestigationList; + } + + public void setExceptionHasInvestigationList(List exceptionHasInvestigationList) { + this.exceptionHasInvestigationList = exceptionHasInvestigationList; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Issue.java b/VM-Core/src/main/java/com/validation/manager/core/db/Issue.java index bf097a94..1ba3108f 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Issue.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Issue.java @@ -13,176 +13,176 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.Date; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.EmbeddedId; -import javax.persistence.Entity; -import javax.persistence.JoinColumn; -import javax.persistence.Lob; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "issue") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Issue.findAll", query = "SELECT i FROM Issue i") - , @NamedQuery(name = "Issue.findById", - query = "SELECT i FROM Issue i WHERE i.issuePK.id = :id") - , @NamedQuery(name = "Issue.findByIssueTypeId", - query = "SELECT i FROM Issue i WHERE i.issuePK.issueTypeId = :issueTypeId") - , @NamedQuery(name = "Issue.findByTitle", - query = "SELECT i FROM Issue i WHERE i.title = :title") - , @NamedQuery(name = "Issue.findByCreationTime", - query = "SELECT i FROM Issue i WHERE i.creationTime = :creationTime")}) -public class Issue implements Serializable { - - private static final long serialVersionUID = 1L; - @EmbeddedId - protected IssuePK issuePK; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "title") - private String title; - @Basic(optional = false) - @NotNull - @Lob - @Size(min = 1, max = 2147483647) - @Column(name = "description") - private String description; - @Basic(optional = false) - @NotNull - @Column(name = "creationTime") - @Temporal(TemporalType.TIMESTAMP) - private Date creationTime; - @JoinColumn(name = "issue_resolution_id", referencedColumnName = "id") - @ManyToOne(optional = false) - private IssueResolution issueResolutionId; - @JoinColumn(name = "issue_type_id", referencedColumnName = "id", - insertable = false, updatable = false) - @ManyToOne(optional = false) - private IssueType issueType; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "issue") - private List executionStepHasIssueList; - - public Issue() { - } - - public Issue(IssuePK issuePK) { - this.issuePK = issuePK; - } - - public Issue(IssuePK issuePK, String title, String description, - Date creationTime) { - this.issuePK = issuePK; - this.title = title; - this.description = description; - this.creationTime = creationTime; - } - - public Issue(int issueTypeId) { - this.issuePK = new IssuePK(issueTypeId); - } - - public IssuePK getIssuePK() { - return issuePK; - } - - public void setIssuePK(IssuePK issuePK) { - this.issuePK = issuePK; - } - - public String getTitle() { - return title; - } - - public void setTitle(String title) { - this.title = title; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - public Date getCreationTime() { - return creationTime; - } - - public void setCreationTime(Date creationTime) { - this.creationTime = creationTime; - } - - public IssueResolution getIssueResolutionId() { - return issueResolutionId; - } - - public void setIssueResolutionId(IssueResolution issueResolutionId) { - this.issueResolutionId = issueResolutionId; - } - - public IssueType getIssueType() { - return issueType; - } - - public void setIssueType(IssueType issueType) { - this.issueType = issueType; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepHasIssueList() { - return executionStepHasIssueList; - } - - public void setExecutionStepHasIssueList(List executionStepHasIssueList) { - this.executionStepHasIssueList = executionStepHasIssueList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (issuePK != null ? issuePK.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof Issue)) { - return false; - } - Issue other = (Issue) object; - return !((this.issuePK == null && other.issuePK != null) - || (this.issuePK != null && !this.issuePK.equals(other.issuePK))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Issue[ issuePK=" + issuePK + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.Date; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.Lob; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "issue") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Issue.findAll", query = "SELECT i FROM Issue i") + , @NamedQuery(name = "Issue.findById", + query = "SELECT i FROM Issue i WHERE i.issuePK.id = :id") + , @NamedQuery(name = "Issue.findByIssueTypeId", + query = "SELECT i FROM Issue i WHERE i.issuePK.issueTypeId = :issueTypeId") + , @NamedQuery(name = "Issue.findByTitle", + query = "SELECT i FROM Issue i WHERE i.title = :title") + , @NamedQuery(name = "Issue.findByCreationTime", + query = "SELECT i FROM Issue i WHERE i.creationTime = :creationTime")}) +public class Issue implements Serializable { + + private static final long serialVersionUID = 1L; + @EmbeddedId + protected IssuePK issuePK; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "title") + private String title; + @Basic(optional = false) + @NotNull + @Lob + @Size(min = 1, max = 2_147_483_647) + @Column(name = "description") + private String description; + @Basic(optional = false) + @NotNull + @Column(name = "creationTime") + @Temporal(TemporalType.TIMESTAMP) + private Date creationTime; + @JoinColumn(name = "issue_resolution_id", referencedColumnName = "id") + @ManyToOne(optional = false) + private IssueResolution issueResolutionId; + @JoinColumn(name = "issue_type_id", referencedColumnName = "id", + insertable = false, updatable = false) + @ManyToOne(optional = false) + private IssueType issueType; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "issue") + private List executionStepHasIssueList; + + public Issue() { + } + + public Issue(IssuePK issuePK) { + this.issuePK = issuePK; + } + + public Issue(IssuePK issuePK, String title, String description, + Date creationTime) { + this.issuePK = issuePK; + this.title = title; + this.description = description; + this.creationTime = creationTime; + } + + public Issue(int issueTypeId) { + this.issuePK = new IssuePK(issueTypeId); + } + + public IssuePK getIssuePK() { + return issuePK; + } + + public void setIssuePK(IssuePK issuePK) { + this.issuePK = issuePK; + } + + public String getTitle() { + return title; + } + + public void setTitle(String title) { + this.title = title; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public Date getCreationTime() { + return creationTime; + } + + public void setCreationTime(Date creationTime) { + this.creationTime = creationTime; + } + + public IssueResolution getIssueResolutionId() { + return issueResolutionId; + } + + public void setIssueResolutionId(IssueResolution issueResolutionId) { + this.issueResolutionId = issueResolutionId; + } + + public IssueType getIssueType() { + return issueType; + } + + public void setIssueType(IssueType issueType) { + this.issueType = issueType; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepHasIssueList() { + return executionStepHasIssueList; + } + + public void setExecutionStepHasIssueList(List executionStepHasIssueList) { + this.executionStepHasIssueList = executionStepHasIssueList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (issuePK != null ? issuePK.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof Issue)) { + return false; + } + Issue other = (Issue) object; + return !((this.issuePK == null && other.issuePK != null) + || (this.issuePK != null && !this.issuePK.equals(other.issuePK))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Issue[ issuePK=" + issuePK + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/IssueResolution.java b/VM-Core/src/main/java/com/validation/manager/core/db/IssueResolution.java index 9816c790..e0b3c8d4 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/IssueResolution.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/IssueResolution.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,123 +13,123 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "issue_resolution") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "IssueResolution.findAll", - query = "SELECT i FROM IssueResolution i") - , @NamedQuery(name = "IssueResolution.findById", - query = "SELECT i FROM IssueResolution i WHERE i.id = :id") - , @NamedQuery(name = "IssueResolution.findByName", - query = "SELECT i FROM IssueResolution i WHERE i.name = :name")}) -public class IssueResolution implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @NotNull - @Column(name = "id") - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "ISSUE_RESOLUTION_IDGEN") - @TableGenerator(name = "ISSUE_RESOLUTION_IDGEN", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "issue_resolution", - initialValue = 1, - allocationSize = 1) - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 45) - @Column(name = "name") - private String name; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "issueResolutionId") - private List issueList; - - public IssueResolution() { - } - - public IssueResolution(Integer id) { - this.id = id; - } - - public IssueResolution(Integer id, String name) { - this.id = id; - this.name = name; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - @XmlTransient - @JsonIgnore - public List getIssueList() { - return issueList; - } - - public void setIssueList(List issueList) { - this.issueList = issueList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof IssueResolution)) { - return false; - } - IssueResolution other = (IssueResolution) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.IssueResolution[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "issue_resolution") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "IssueResolution.findAll", + query = "SELECT i FROM IssueResolution i") + , @NamedQuery(name = "IssueResolution.findById", + query = "SELECT i FROM IssueResolution i WHERE i.id = :id") + , @NamedQuery(name = "IssueResolution.findByName", + query = "SELECT i FROM IssueResolution i WHERE i.name = :name")}) +public class IssueResolution implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @NotNull + @Column(name = "id") + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "ISSUE_RESOLUTION_IDGEN") + @TableGenerator(name = "ISSUE_RESOLUTION_IDGEN", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "issue_resolution", + initialValue = 1_000, + allocationSize = 1) + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 45) + @Column(name = "name") + private String name; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "issueResolutionId") + private List issueList; + + public IssueResolution() { + } + + public IssueResolution(Integer id) { + this.id = id; + } + + public IssueResolution(Integer id, String name) { + this.id = id; + this.name = name; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + @XmlTransient + @JsonIgnore + public List getIssueList() { + return issueList; + } + + public void setIssueList(List issueList) { + this.issueList = issueList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof IssueResolution)) { + return false; + } + IssueResolution other = (IssueResolution) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.IssueResolution[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/IssueType.java b/VM-Core/src/main/java/com/validation/manager/core/db/IssueType.java index 7ffc2ada..7aee0e0a 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/IssueType.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/IssueType.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,137 +13,132 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.Lob; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "issue_type") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "IssueType.findAll", - query = "SELECT i FROM IssueType i") - , @NamedQuery(name = "IssueType.findById", - query = "SELECT i FROM IssueType i WHERE i.id = :id") - , @NamedQuery(name = "IssueType.findByTypeName", - query = "SELECT i FROM IssueType i WHERE i.typeName = :typeName")}) -public class IssueType implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @NotNull - @Column(name = "id") - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "ISSUE_TYPE_IDGEN") - @TableGenerator(name = "ISSUE_TYPE_IDGEN", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "issue_type", - initialValue = 1, - allocationSize = 1) - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 45) - @Column(name = "type_name") - private String typeName; - @Lob - @Size(max = 2147483647) - @Column(name = "description") - private String description; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "issueType") - private List issueList; - - public IssueType() { - } - - public IssueType(Integer id) { - this.id = id; - } - - public IssueType(Integer id, String typeName) { - this.id = id; - this.typeName = typeName; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getTypeName() { - return typeName; - } - - public void setTypeName(String typeName) { - this.typeName = typeName; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getIssueList() { - return issueList; - } - - public void setIssueList(List issueList) { - this.issueList = issueList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof IssueType)) { - return false; - } - IssueType other = (IssueType) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.IssueType[ id=" + id + " ]"; - } - -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "issue_type") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "IssueType.findAll", + query = "SELECT i FROM IssueType i") + , @NamedQuery(name = "IssueType.findById", + query = "SELECT i FROM IssueType i WHERE i.id = :id") + , @NamedQuery(name = "IssueType.findByTypeName", + query = "SELECT i FROM IssueType i WHERE i.typeName = :typeName")}) +public class IssueType implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @NotNull + @Column(name = "id") + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "ISSUE_TYPE_IDGEN") + @TableGenerator(name = "ISSUE_TYPE_IDGEN", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "issue_type", + initialValue = 1_000, + allocationSize = 1) + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 45) + @Column(name = "type_name") + private String typeName; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "description") + private String description; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "issueType") + private List issueList; + + public IssueType() { + } + + public IssueType(String typeName) { + this.typeName = typeName; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getTypeName() { + return typeName; + } + + public void setTypeName(String typeName) { + this.typeName = typeName; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getIssueList() { + return issueList; + } + + public void setIssueList(List issueList) { + this.issueList = issueList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof IssueType)) { + return false; + } + IssueType other = (IssueType) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.IssueType[ id=" + id + " ]"; + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Notification.java b/VM-Core/src/main/java/com/validation/manager/core/db/Notification.java index a3c8912d..f4e3ceb8 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Notification.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Notification.java @@ -13,182 +13,182 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.Date; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.EmbeddedId; -import javax.persistence.Entity; -import javax.persistence.JoinColumn; -import javax.persistence.Lob; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.Table; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "notification") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Notification.findAll", - query = "SELECT n FROM Notification n") - , @NamedQuery(name = "Notification.findById", - query = "SELECT n FROM Notification n WHERE n.notificationPK.id = :id") - , @NamedQuery(name = "Notification.findByNotificationTypeId", - query = "SELECT n FROM Notification n WHERE n.notificationPK.notificationTypeId = :notificationTypeId") - , @NamedQuery(name = "Notification.findByCreationDate", - query = "SELECT n FROM Notification n WHERE n.creationDate = :creationDate") - , @NamedQuery(name = "Notification.findByAcknowledgeDate", - query = "SELECT n FROM Notification n WHERE n.acknowledgeDate = :acknowledgeDate")}) -public class Notification implements Serializable { - - private static final long serialVersionUID = 1L; - @EmbeddedId - protected NotificationPK notificationPK; - @Basic(optional = false) - @NotNull - @Lob - @Size(min = 1, max = 2147483647) - @Column(name = "content") - private String content; - @Basic(optional = false) - @NotNull - @Column(name = "creation_date") - @Temporal(TemporalType.TIMESTAMP) - private Date creationDate; - @Column(name = "acknowledge_date") - @Temporal(TemporalType.TIMESTAMP) - private Date acknowledgeDate; - @JoinColumn(name = "notification_type_id", referencedColumnName = "id", - insertable = false, updatable = false) - @ManyToOne(optional = false) - private NotificationType notificationType; - @JoinColumn(name = "target_user", referencedColumnName = "id") - @ManyToOne(optional = false) - private VmUser targetUser; - @JoinColumn(name = "author", referencedColumnName = "id") - @ManyToOne(optional = false) - private VmUser author; - @Basic(optional = false) - @NotNull - @Column(name = "archieved") - private boolean archieved; - - public Notification() { - } - - public Notification(NotificationPK notificationPK) { - this.notificationPK = notificationPK; - } - - public Notification(NotificationPK notificationPK, String content, Date creationDate) { - this.notificationPK = notificationPK; - this.content = content; - this.creationDate = creationDate; - } - - public Notification(int id, int notificationTypeId) { - this.notificationPK = new NotificationPK(id, notificationTypeId); - } - - public NotificationPK getNotificationPK() { - return notificationPK; - } - - public void setNotificationPK(NotificationPK notificationPK) { - this.notificationPK = notificationPK; - } - - public String getContent() { - return content; - } - - public void setContent(String content) { - this.content = content; - } - - public Date getCreationDate() { - return creationDate; - } - - public void setCreationDate(Date creationDate) { - this.creationDate = creationDate; - } - - public Date getAcknowledgeDate() { - return acknowledgeDate; - } - - public void setAcknowledgeDate(Date acknowledgeDate) { - this.acknowledgeDate = acknowledgeDate; - } - - public NotificationType getNotificationType() { - return notificationType; - } - - public void setNotificationType(NotificationType notificationType) { - this.notificationType = notificationType; - } - - public VmUser getTargetUser() { - return targetUser; - } - - public void setTargetUser(VmUser targetUser) { - this.targetUser = targetUser; - } - - public VmUser getAuthor() { - return author; - } - - public void setAuthor(VmUser author) { - this.author = author; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (notificationPK != null ? notificationPK.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - // TODO: Warning - this method won't work in the case the id fields are not set - if (!(object instanceof Notification)) { - return false; - } - Notification other = (Notification) object; - if ((this.notificationPK == null && other.notificationPK != null) || (this.notificationPK != null && !this.notificationPK.equals(other.notificationPK))) { - return false; - } - return true; - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Notification[ notificationPK=" + notificationPK + " ]"; - } - - public boolean getArchieved() { - return archieved; - } - - public void setArchieved(boolean archieved) { - this.archieved = archieved; - } - -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.Date; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.Lob; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.Table; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "notification") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Notification.findAll", + query = "SELECT n FROM Notification n") + , @NamedQuery(name = "Notification.findById", + query = "SELECT n FROM Notification n WHERE n.notificationPK.id = :id") + , @NamedQuery(name = "Notification.findByNotificationTypeId", + query = "SELECT n FROM Notification n WHERE n.notificationPK.notificationTypeId = :notificationTypeId") + , @NamedQuery(name = "Notification.findByCreationDate", + query = "SELECT n FROM Notification n WHERE n.creationDate = :creationDate") + , @NamedQuery(name = "Notification.findByAcknowledgeDate", + query = "SELECT n FROM Notification n WHERE n.acknowledgeDate = :acknowledgeDate")}) +public class Notification implements Serializable { + + private static final long serialVersionUID = 1L; + @EmbeddedId + protected NotificationPK notificationPK; + @Basic(optional = false) + @NotNull + @Lob + @Size(min = 1, max = 2_147_483_647) + @Column(name = "content") + private String content; + @Basic(optional = false) + @NotNull + @Column(name = "creation_date") + @Temporal(TemporalType.TIMESTAMP) + private Date creationDate; + @Column(name = "acknowledge_date") + @Temporal(TemporalType.TIMESTAMP) + private Date acknowledgeDate; + @JoinColumn(name = "notification_type_id", referencedColumnName = "id", + insertable = false, updatable = false) + @ManyToOne(optional = false) + private NotificationType notificationType; + @JoinColumn(name = "target_user", referencedColumnName = "id") + @ManyToOne(optional = false) + private VmUser targetUser; + @JoinColumn(name = "author", referencedColumnName = "id") + @ManyToOne(optional = false) + private VmUser author; + @Basic(optional = false) + @NotNull + @Column(name = "archieved") + private boolean archieved; + + public Notification() { + } + + public Notification(NotificationPK notificationPK) { + this.notificationPK = notificationPK; + } + + public Notification(NotificationPK notificationPK, String content, Date creationDate) { + this.notificationPK = notificationPK; + this.content = content; + this.creationDate = creationDate; + } + + public Notification(int id, int notificationTypeId) { + this.notificationPK = new NotificationPK(id, notificationTypeId); + } + + public NotificationPK getNotificationPK() { + return notificationPK; + } + + public void setNotificationPK(NotificationPK notificationPK) { + this.notificationPK = notificationPK; + } + + public String getContent() { + return content; + } + + public void setContent(String content) { + this.content = content; + } + + public Date getCreationDate() { + return creationDate; + } + + public void setCreationDate(Date creationDate) { + this.creationDate = creationDate; + } + + public Date getAcknowledgeDate() { + return acknowledgeDate; + } + + public void setAcknowledgeDate(Date acknowledgeDate) { + this.acknowledgeDate = acknowledgeDate; + } + + public NotificationType getNotificationType() { + return notificationType; + } + + public void setNotificationType(NotificationType notificationType) { + this.notificationType = notificationType; + } + + public VmUser getTargetUser() { + return targetUser; + } + + public void setTargetUser(VmUser targetUser) { + this.targetUser = targetUser; + } + + public VmUser getAuthor() { + return author; + } + + public void setAuthor(VmUser author) { + this.author = author; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (notificationPK != null ? notificationPK.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + // TODO: Warning - this method won't work in the case the id fields are not set + if (!(object instanceof Notification)) { + return false; + } + Notification other = (Notification) object; + if ((this.notificationPK == null && other.notificationPK != null) || (this.notificationPK != null && !this.notificationPK.equals(other.notificationPK))) { + return false; + } + return true; + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Notification[ notificationPK=" + notificationPK + " ]"; + } + + public boolean getArchieved() { + return archieved; + } + + public void setArchieved(boolean archieved) { + this.archieved = archieved; + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/NotificationPK.java b/VM-Core/src/main/java/com/validation/manager/core/db/NotificationPK.java index 2945c91a..59f4b8d2 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/NotificationPK.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/NotificationPK.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,81 +13,92 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Embeddable; -import javax.validation.constraints.NotNull; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Embeddable -public class NotificationPK implements Serializable { - - @Basic(optional = false) - @NotNull - @Column(name = "id") - private int id; - @Basic(optional = false) - @NotNull - @Column(name = "notification_type_id") - private int notificationTypeId; - - public NotificationPK() { - } - - public NotificationPK(int id, int notificationTypeId) { - this.id = id; - this.notificationTypeId = notificationTypeId; - } - - public int getId() { - return id; - } - - public void setId(int id) { - this.id = id; - } - - public int getNotificationTypeId() { - return notificationTypeId; - } - - public void setNotificationTypeId(int notificationTypeId) { - this.notificationTypeId = notificationTypeId; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (int) id; - hash += (int) notificationTypeId; - return hash; - } - - @Override - public boolean equals(Object object) { - // TODO: Warning - this method won't work in the case the id fields are not set - if (!(object instanceof NotificationPK)) { - return false; - } - NotificationPK other = (NotificationPK) object; - if (this.id != other.id) { - return false; - } - if (this.notificationTypeId != other.notificationTypeId) { - return false; - } - return true; - } - - @Override - public String toString() { - return "com.validation.manager.core.db.NotificationPK[ id=" + id + ", notificationTypeId=" + notificationTypeId + " ]"; - } - -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Embeddable; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Embeddable +public class NotificationPK implements Serializable { + + @Basic(optional = false) + @NotNull + @Column(name = "id") + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "Notification_IDGEN") + @TableGenerator(name = "Notification_IDGEN", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "notification", + initialValue = 1, + allocationSize = 1) + private int id; + @Basic(optional = false) + @NotNull + @Column(name = "notification_type_id") + private int notificationTypeId; + + public NotificationPK() { + } + + public NotificationPK(int id, int notificationTypeId) { + this.id = id; + this.notificationTypeId = notificationTypeId; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public int getNotificationTypeId() { + return notificationTypeId; + } + + public void setNotificationTypeId(int notificationTypeId) { + this.notificationTypeId = notificationTypeId; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (int) id; + hash += (int) notificationTypeId; + return hash; + } + + @Override + public boolean equals(Object object) { + // TODO: Warning - this method won't work in the case the id fields are not set + if (!(object instanceof NotificationPK)) { + return false; + } + NotificationPK other = (NotificationPK) object; + if (this.id != other.id) { + return false; + } + if (this.notificationTypeId != other.notificationTypeId) { + return false; + } + return true; + } + + @Override + public String toString() { + return "com.validation.manager.core.db.NotificationPK[ id=" + id + ", notificationTypeId=" + notificationTypeId + " ]"; + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Project.java b/VM-Core/src/main/java/com/validation/manager/core/db/Project.java index 3158f241..0d1bf42b 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Project.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Project.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,190 +13,193 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import com.validation.manager.core.history.Versionable; -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "project") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Project.findAll", - query = "SELECT p FROM Project p") - , @NamedQuery(name = "Project.findById", - query = "SELECT p FROM Project p WHERE p.id = :id") - , @NamedQuery(name = "Project.findByName", - query = "SELECT p FROM Project p WHERE p.name = :name")}) -public class Project extends Versionable implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "ProjectGen") - @TableGenerator(name = "ProjectGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "project", - allocationSize = 1, - initialValue = 1000) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Lob - @Size(max = 2147483647) - @Column(name = "notes") - private String notes; - @JoinTable(name = "project_has_test_project", joinColumns = { - @JoinColumn(name = "project_id", referencedColumnName = "id")}, - inverseJoinColumns = { - @JoinColumn(name = "test_project_id", - referencedColumnName = "id")}) - @ManyToMany - private List testProjectList; - @OneToMany(mappedBy = "parentProjectId") - private List projectList; - @JoinColumn(name = "parent_project_id", referencedColumnName = "id") - @ManyToOne - private Project parentProjectId; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "project") - private List requirementSpecList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "projectId") - private List historyList; - - public Project(String name) { - this.name = name; - } - - public Project() { - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getNotes() { - return notes; - } - - public void setNotes(String notes) { - this.notes = notes; - } - - @XmlTransient - @JsonIgnore - public List getTestProjectList() { - return testProjectList; - } - - public void setTestProjectList(List testProjectList) { - this.testProjectList = testProjectList; - } - - @XmlTransient - @JsonIgnore - public List getProjectList() { - return projectList; - } - - public void setProjectList(List projectList) { - this.projectList = projectList; - } - - public Project getParentProjectId() { - return parentProjectId; - } - - public void setParentProjectId(Project parentProjectId) { - this.parentProjectId = parentProjectId; - } - - @XmlTransient - @JsonIgnore - public List getRequirementSpecList() { - return requirementSpecList; - } - - public void setRequirementSpecList(List requirementSpecList) { - this.requirementSpecList = requirementSpecList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof Project)) { - return false; - } - Project other = (Project) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Project[ id=" + id + " ]"; - } - - @XmlTransient - @JsonIgnore - @Override - public List getHistoryList() { - return historyList; - } - - @Override - public void setHistoryList(List historyList) { - this.historyList = historyList; - } -} +package com.validation.manager.core.db; + +import com.validation.manager.core.history.Auditable; +import com.validation.manager.core.history.Versionable; +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "project") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Project.findAll", + query = "SELECT p FROM Project p") + , @NamedQuery(name = "Project.findById", + query = "SELECT p FROM Project p WHERE p.id = :id") + , @NamedQuery(name = "Project.findByName", + query = "SELECT p FROM Project p WHERE p.name = :name")}) +public class Project extends Versionable implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "ProjectGen") + @TableGenerator(name = "ProjectGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "project", + allocationSize = 1, + initialValue = 1_000) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + @Auditable + private String name; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "notes") + @Auditable + private String notes; + @JoinTable(name = "project_has_test_project", joinColumns = { + @JoinColumn(name = "project_id", referencedColumnName = "id")}, + inverseJoinColumns = { + @JoinColumn(name = "test_project_id", + referencedColumnName = "id")}) + @ManyToMany + private List testProjectList; + @OneToMany(mappedBy = "parentProjectId") + private List projectList; + @JoinColumn(name = "parent_project_id", referencedColumnName = "id") + @ManyToOne + private Project parentProjectId; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "project") + private List requirementSpecList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "projectId") + private List historyList; + + public Project(String name) { + this.name = name; + } + + public Project() { + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getNotes() { + return notes; + } + + public void setNotes(String notes) { + this.notes = notes; + } + + @XmlTransient + @JsonIgnore + public List getTestProjectList() { + return testProjectList; + } + + public void setTestProjectList(List testProjectList) { + this.testProjectList = testProjectList; + } + + @XmlTransient + @JsonIgnore + public List getProjectList() { + return projectList; + } + + public void setProjectList(List projectList) { + this.projectList = projectList; + } + + public Project getParentProjectId() { + return parentProjectId; + } + + public void setParentProjectId(Project parentProjectId) { + this.parentProjectId = parentProjectId; + } + + @XmlTransient + @JsonIgnore + public List getRequirementSpecList() { + return requirementSpecList; + } + + public void setRequirementSpecList(List requirementSpecList) { + this.requirementSpecList = requirementSpecList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof Project)) { + return false; + } + Project other = (Project) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Project[ id=" + id + " ]"; + } + + @XmlTransient + @JsonIgnore + @Override + public List getHistoryList() { + return historyList; + } + + @Override + public void setHistoryList(List historyList) { + this.historyList = historyList; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Requirement.java b/VM-Core/src/main/java/com/validation/manager/core/db/Requirement.java index bd0f08d0..bbadbe2b 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Requirement.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Requirement.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,265 +13,265 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import com.validation.manager.core.history.Auditable; -import com.validation.manager.core.history.Versionable; -import java.io.Serializable; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinColumns; -import javax.persistence.JoinTable; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "requirement") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Requirement.findAll", - query = "SELECT r FROM Requirement r") - , @NamedQuery(name = "Requirement.findById", - query = "SELECT r FROM Requirement r WHERE r.id = :id") - , @NamedQuery(name = "Requirement.findByUniqueId", - query = "SELECT r FROM Requirement r WHERE r.uniqueId = :uniqueId")}) -public class Requirement extends Versionable implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "ReqGen") - @TableGenerator(name = "ReqGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "requirement", - allocationSize = 1, - initialValue = 1000) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "unique_id") - @Auditable - private String uniqueId; - @Basic(optional = false) - @NotNull - @Lob - @Size(max = 2147483647) - @Column(name = "description") - @Auditable - private String description; - @Lob - @Size(max = 2147483647) - @Column(name = "notes") - @Auditable - private String notes; - @OneToMany(mappedBy = "parentRequirementId") - private List requirementList; - @JoinTable(name = "step_has_requirement", joinColumns = { - @JoinColumn(name = "requirement_id", referencedColumnName = "id")}, - inverseJoinColumns = { - @JoinColumn(name = "step_id", referencedColumnName = "id") - , @JoinColumn(name = "step_test_case_id", - referencedColumnName = "test_case_id")}) - @ManyToMany - private List stepList; - @JoinColumn(name = "parent_requirement_id", referencedColumnName = "id") - @ManyToOne - private Requirement parentRequirementId; - @JoinColumns({ - @JoinColumn(name = "requirement_spec_node_id", - referencedColumnName = "id") - , @JoinColumn(name = "requirement_spec_node_requirement_spec_id", - referencedColumnName = "requirement_spec_id") - , @JoinColumn(name = "requirement_spec_node_requirement_spec_project_id", - referencedColumnName = "requirement_spec_project_id") - , @JoinColumn(name = "requirement_spec_node_requirement_spec_spec_level_id", - referencedColumnName = "requirement_spec_spec_level_id")}) - @ManyToOne(optional = false) - private RequirementSpecNode requirementSpecNode; - @JoinColumn(name = "requirement_status_id", referencedColumnName = "id") - @ManyToOne(optional = false) - private RequirementStatus requirementStatusId; - @JoinColumn(name = "requirement_type_id", referencedColumnName = "id") - @ManyToOne(optional = false) - private RequirementType requirementTypeId; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirement") - private List riskControlHasRequirementList; - @OneToMany(mappedBy = "requirementId") - private List historyList; - - public Requirement() { - super(); - } - - public Requirement(String uniqueId, String description) { - this.uniqueId = uniqueId; - this.description = description; - } - - public Requirement(String uniqueId, String description, String notes) { - this.uniqueId = uniqueId; - this.description = description; - this.notes = notes; - setRiskControlHasRequirementList(new ArrayList<>()); - setRequirementList(new ArrayList<>()); - setStepList(new ArrayList<>()); - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getUniqueId() { - return uniqueId; - } - - public void setUniqueId(String uniqueId) { - this.uniqueId = uniqueId; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - public String getNotes() { - return notes; - } - - public void setNotes(String notes) { - this.notes = notes; - } - - @XmlTransient - @JsonIgnore - public List getRequirementList() { - return requirementList; - } - - public void setRequirementList(List requirementList) { - this.requirementList = requirementList; - } - - public Requirement getParentRequirementId() { - return parentRequirementId; - } - - public void setParentRequirementId(Requirement parentRequirementId) { - this.parentRequirementId = parentRequirementId; - } - - @XmlTransient - @JsonIgnore - public List getStepList() { - return stepList; - } - - public void setStepList(List stepList) { - this.stepList = stepList; - } - - public RequirementSpecNode getRequirementSpecNode() { - return requirementSpecNode; - } - - public void setRequirementSpecNode(RequirementSpecNode requirementSpecNode) { - this.requirementSpecNode = requirementSpecNode; - } - - public RequirementStatus getRequirementStatusId() { - return requirementStatusId; - } - - public void setRequirementStatusId(RequirementStatus requirementStatusId) { - this.requirementStatusId = requirementStatusId; - } - - public RequirementType getRequirementTypeId() { - return requirementTypeId; - } - - public void setRequirementTypeId(RequirementType requirementTypeId) { - this.requirementTypeId = requirementTypeId; - } - - @XmlTransient - @JsonIgnore - public List getRiskControlHasRequirementList() { - return riskControlHasRequirementList; - } - - public void setRiskControlHasRequirementList(List riskControlHasRequirementList) { - this.riskControlHasRequirementList = riskControlHasRequirementList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - if (!(object instanceof Requirement)) { - return false; - } - Requirement other = (Requirement) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Requirement[ id=" + getId() - + ", uniqueId=" + getUniqueId() - + ", description=" + getDescription() - + " " + super.toString() + " ]"; - } - - @XmlTransient - @JsonIgnore - @Override - public List getHistoryList() { - return historyList; - } - - @Override - public void setHistoryList(List historyList) { - this.historyList = historyList; - } -} +package com.validation.manager.core.db; + +import com.validation.manager.core.history.Auditable; +import com.validation.manager.core.history.Versionable; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinColumns; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "requirement") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Requirement.findAll", + query = "SELECT r FROM Requirement r") + , @NamedQuery(name = "Requirement.findById", + query = "SELECT r FROM Requirement r WHERE r.id = :id") + , @NamedQuery(name = "Requirement.findByUniqueId", + query = "SELECT r FROM Requirement r WHERE r.uniqueId = :uniqueId")}) +public class Requirement extends Versionable implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "ReqGen") + @TableGenerator(name = "ReqGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "requirement", + allocationSize = 1, + initialValue = 1_000) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "unique_id") + @Auditable + private String uniqueId; + @Basic(optional = false) + @NotNull + @Lob + @Size(max = 2_147_483_647) + @Column(name = "description") + @Auditable + private String description; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "notes") + @Auditable + private String notes; + @OneToMany(mappedBy = "parentRequirementId") + private List requirementList; + @JoinTable(name = "step_has_requirement", joinColumns = { + @JoinColumn(name = "requirement_id", referencedColumnName = "id")}, + inverseJoinColumns = { + @JoinColumn(name = "step_id", referencedColumnName = "id") + , @JoinColumn(name = "step_test_case_id", + referencedColumnName = "test_case_id")}) + @ManyToMany + private List stepList; + @JoinColumn(name = "parent_requirement_id", referencedColumnName = "id") + @ManyToOne + private Requirement parentRequirementId; + @JoinColumns({ + @JoinColumn(name = "requirement_spec_node_id", + referencedColumnName = "id") + , @JoinColumn(name = "requirement_spec_node_requirement_spec_id", + referencedColumnName = "requirement_spec_id") + , @JoinColumn(name = "requirement_spec_node_requirement_spec_project_id", + referencedColumnName = "requirement_spec_project_id") + , @JoinColumn(name = "requirement_spec_node_requirement_spec_spec_level_id", + referencedColumnName = "requirement_spec_spec_level_id")}) + @ManyToOne(optional = false) + private RequirementSpecNode requirementSpecNode; + @JoinColumn(name = "requirement_status_id", referencedColumnName = "id") + @ManyToOne(optional = false) + private RequirementStatus requirementStatusId; + @JoinColumn(name = "requirement_type_id", referencedColumnName = "id") + @ManyToOne(optional = false) + private RequirementType requirementTypeId; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirement") + private List riskControlHasRequirementList; + @OneToMany(mappedBy = "requirementId") + private List historyList; + + public Requirement() { + super(); + } + + public Requirement(String uniqueId, String description) { + this.uniqueId = uniqueId; + this.description = description; + } + + public Requirement(String uniqueId, String description, String notes) { + this.uniqueId = uniqueId; + this.description = description; + this.notes = notes; + setRiskControlHasRequirementList(new ArrayList<>()); + setRequirementList(new ArrayList<>()); + setStepList(new ArrayList<>()); + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getUniqueId() { + return uniqueId; + } + + public void setUniqueId(String uniqueId) { + this.uniqueId = uniqueId; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public String getNotes() { + return notes; + } + + public void setNotes(String notes) { + this.notes = notes; + } + + @XmlTransient + @JsonIgnore + public List getRequirementList() { + return requirementList; + } + + public void setRequirementList(List requirementList) { + this.requirementList = requirementList; + } + + public Requirement getParentRequirementId() { + return parentRequirementId; + } + + public void setParentRequirementId(Requirement parentRequirementId) { + this.parentRequirementId = parentRequirementId; + } + + @XmlTransient + @JsonIgnore + public List getStepList() { + return stepList; + } + + public void setStepList(List stepList) { + this.stepList = stepList; + } + + public RequirementSpecNode getRequirementSpecNode() { + return requirementSpecNode; + } + + public void setRequirementSpecNode(RequirementSpecNode requirementSpecNode) { + this.requirementSpecNode = requirementSpecNode; + } + + public RequirementStatus getRequirementStatusId() { + return requirementStatusId; + } + + public void setRequirementStatusId(RequirementStatus requirementStatusId) { + this.requirementStatusId = requirementStatusId; + } + + public RequirementType getRequirementTypeId() { + return requirementTypeId; + } + + public void setRequirementTypeId(RequirementType requirementTypeId) { + this.requirementTypeId = requirementTypeId; + } + + @XmlTransient + @JsonIgnore + public List getRiskControlHasRequirementList() { + return riskControlHasRequirementList; + } + + public void setRiskControlHasRequirementList(List riskControlHasRequirementList) { + this.riskControlHasRequirementList = riskControlHasRequirementList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + if (!(object instanceof Requirement)) { + return false; + } + Requirement other = (Requirement) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Requirement[ id=" + getId() + + ", uniqueId=" + getUniqueId() + + ", description=" + getDescription() + + " " + super.toString() + " ]"; + } + + @XmlTransient + @JsonIgnore + @Override + public List getHistoryList() { + return historyList; + } + + @Override + public void setHistoryList(List historyList) { + this.historyList = historyList; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpec.java b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpec.java index 311ed1af..961d9360 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpec.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpec.java @@ -13,195 +13,195 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.Date; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.EmbeddedId; -import javax.persistence.Entity; -import javax.persistence.JoinColumn; -import javax.persistence.Lob; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "requirement_spec") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "RequirementSpec.findAll", - query = "SELECT r FROM RequirementSpec r") - , @NamedQuery(name = "RequirementSpec.findById", - query = "SELECT r FROM RequirementSpec r WHERE r.requirementSpecPK.id = :id") - , @NamedQuery(name = "RequirementSpec.findByProjectId", - query = "SELECT r FROM RequirementSpec r WHERE r.requirementSpecPK.projectId = :projectId") - , @NamedQuery(name = "RequirementSpec.findBySpecLevelId", - query = "SELECT r FROM RequirementSpec r WHERE r.requirementSpecPK.specLevelId = :specLevelId") - , @NamedQuery(name = "RequirementSpec.findByName", - query = "SELECT r FROM RequirementSpec r WHERE r.name = :name") - , @NamedQuery(name = "RequirementSpec.findByModificationDate", - query = "SELECT r FROM RequirementSpec r WHERE r.modificationDate = :modificationDate")}) -public class RequirementSpec implements Serializable { - - private static final long serialVersionUID = 1L; - @EmbeddedId - protected RequirementSpecPK requirementSpecPK; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Lob - @Size(max = 2147483647) - @Column(name = "description") - private String description; - @Basic(optional = false) - @NotNull - @Column(name = "modificationDate") - @Temporal(TemporalType.TIMESTAMP) - private Date modificationDate; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirementSpec") - private List requirementSpecNodeList; - @JoinColumn(name = "project_id", referencedColumnName = "id", - insertable = false, updatable = false) - @ManyToOne(optional = false) - private Project project; - @JoinColumn(name = "spec_level_id", referencedColumnName = "id", - insertable = false, updatable = false) - @ManyToOne(optional = false) - private SpecLevel specLevel; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirementSpec") - private List baselineList; - - public RequirementSpec() { - super(); - } - - public RequirementSpec(RequirementSpecPK requirementSpecPK) { - this.requirementSpecPK = requirementSpecPK; - } - - public RequirementSpec(RequirementSpecPK requirementSpecPK, - String name, Date modificationDate) { - super(); - this.requirementSpecPK = requirementSpecPK; - this.name = name; - this.modificationDate = modificationDate; - } - - public RequirementSpec(int projectId, int specLevelId) { - super(); - this.requirementSpecPK = new RequirementSpecPK(projectId, specLevelId); - } - - public RequirementSpecPK getRequirementSpecPK() { - return requirementSpecPK; - } - - public void setRequirementSpecPK(RequirementSpecPK requirementSpecPK) { - this.requirementSpecPK = requirementSpecPK; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - public Date getModificationDate() { - return modificationDate; - } - - public void setModificationDate(Date modificationDate) { - this.modificationDate = modificationDate; - } - - @XmlTransient - @JsonIgnore - public List getRequirementSpecNodeList() { - return requirementSpecNodeList; - } - - public void setRequirementSpecNodeList(List requirementSpecNodeList) { - this.requirementSpecNodeList = requirementSpecNodeList; - } - - public Project getProject() { - return project; - } - - public void setProject(Project project) { - this.project = project; - } - - public SpecLevel getSpecLevel() { - return specLevel; - } - - public void setSpecLevel(SpecLevel specLevel) { - this.specLevel = specLevel; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (requirementSpecPK != null ? requirementSpecPK.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RequirementSpec)) { - return false; - } - RequirementSpec other = (RequirementSpec) object; - return !((this.requirementSpecPK == null - && other.requirementSpecPK != null) - || (this.requirementSpecPK != null - && !this.requirementSpecPK.equals(other.requirementSpecPK))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RequirementSpec[ requirementSpecPK=" - + requirementSpecPK + " ]"; - } - - @XmlTransient - @JsonIgnore - public List getBaselineList() { - return baselineList; - } - - public void setBaselineList(List baselineList) { - this.baselineList = baselineList; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.Date; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.Lob; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "requirement_spec") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "RequirementSpec.findAll", + query = "SELECT r FROM RequirementSpec r") + , @NamedQuery(name = "RequirementSpec.findById", + query = "SELECT r FROM RequirementSpec r WHERE r.requirementSpecPK.id = :id") + , @NamedQuery(name = "RequirementSpec.findByProjectId", + query = "SELECT r FROM RequirementSpec r WHERE r.requirementSpecPK.projectId = :projectId") + , @NamedQuery(name = "RequirementSpec.findBySpecLevelId", + query = "SELECT r FROM RequirementSpec r WHERE r.requirementSpecPK.specLevelId = :specLevelId") + , @NamedQuery(name = "RequirementSpec.findByName", + query = "SELECT r FROM RequirementSpec r WHERE r.name = :name") + , @NamedQuery(name = "RequirementSpec.findByModificationDate", + query = "SELECT r FROM RequirementSpec r WHERE r.modificationDate = :modificationDate")}) +public class RequirementSpec implements Serializable { + + private static final long serialVersionUID = 1L; + @EmbeddedId + protected RequirementSpecPK requirementSpecPK; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "description") + private String description; + @Basic(optional = false) + @NotNull + @Column(name = "modificationDate") + @Temporal(TemporalType.TIMESTAMP) + private Date modificationDate; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirementSpec") + private List requirementSpecNodeList; + @JoinColumn(name = "project_id", referencedColumnName = "id", + insertable = false, updatable = false) + @ManyToOne(optional = false) + private Project project; + @JoinColumn(name = "spec_level_id", referencedColumnName = "id", + insertable = false, updatable = false) + @ManyToOne(optional = false) + private SpecLevel specLevel; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirementSpec") + private List baselineList; + + public RequirementSpec() { + super(); + } + + public RequirementSpec(RequirementSpecPK requirementSpecPK) { + this.requirementSpecPK = requirementSpecPK; + } + + public RequirementSpec(RequirementSpecPK requirementSpecPK, + String name, Date modificationDate) { + super(); + this.requirementSpecPK = requirementSpecPK; + this.name = name; + this.modificationDate = modificationDate; + } + + public RequirementSpec(int projectId, int specLevelId) { + super(); + this.requirementSpecPK = new RequirementSpecPK(projectId, specLevelId); + } + + public RequirementSpecPK getRequirementSpecPK() { + return requirementSpecPK; + } + + public void setRequirementSpecPK(RequirementSpecPK requirementSpecPK) { + this.requirementSpecPK = requirementSpecPK; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public Date getModificationDate() { + return modificationDate; + } + + public void setModificationDate(Date modificationDate) { + this.modificationDate = modificationDate; + } + + @XmlTransient + @JsonIgnore + public List getRequirementSpecNodeList() { + return requirementSpecNodeList; + } + + public void setRequirementSpecNodeList(List requirementSpecNodeList) { + this.requirementSpecNodeList = requirementSpecNodeList; + } + + public Project getProject() { + return project; + } + + public void setProject(Project project) { + this.project = project; + } + + public SpecLevel getSpecLevel() { + return specLevel; + } + + public void setSpecLevel(SpecLevel specLevel) { + this.specLevel = specLevel; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (requirementSpecPK != null ? requirementSpecPK.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RequirementSpec)) { + return false; + } + RequirementSpec other = (RequirementSpec) object; + return !((this.requirementSpecPK == null + && other.requirementSpecPK != null) + || (this.requirementSpecPK != null + && !this.requirementSpecPK.equals(other.requirementSpecPK))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RequirementSpec[ requirementSpecPK=" + + requirementSpecPK + " ]"; + } + + @XmlTransient + @JsonIgnore + public List getBaselineList() { + return baselineList; + } + + public void setBaselineList(List baselineList) { + this.baselineList = baselineList; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecNode.java b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecNode.java index 8a322c02..abe1f015 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecNode.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecNode.java @@ -13,210 +13,210 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.EmbeddedId; -import javax.persistence.Entity; -import javax.persistence.JoinColumn; -import javax.persistence.JoinColumns; -import javax.persistence.Lob; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "requirement_spec_node") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "RequirementSpecNode.findAll", - query = "SELECT r FROM RequirementSpecNode r") - , @NamedQuery(name = "RequirementSpecNode.findById", - query = "SELECT r FROM RequirementSpecNode r WHERE r.requirementSpecNodePK.id = :id") - , @NamedQuery(name = "RequirementSpecNode.findByRequirementSpecId", - query = "SELECT r FROM RequirementSpecNode r WHERE r.requirementSpecNodePK.requirementSpecId = :requirementSpecId") - , @NamedQuery(name = "RequirementSpecNode.findByRequirementSpecProjectId", - query = "SELECT r FROM RequirementSpecNode r WHERE r.requirementSpecNodePK.requirementSpecProjectId = :requirementSpecProjectId") - , @NamedQuery(name = "RequirementSpecNode.findByRequirementSpecSpecLevelId", - query = "SELECT r FROM RequirementSpecNode r WHERE r.requirementSpecNodePK.requirementSpecSpecLevelId = :requirementSpecSpecLevelId") - , @NamedQuery(name = "RequirementSpecNode.findByName", - query = "SELECT r FROM RequirementSpecNode r WHERE r.name = :name")}) -public class RequirementSpecNode implements Serializable { - - private static final long serialVersionUID = 1L; - @EmbeddedId - protected RequirementSpecNodePK requirementSpecNodePK; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Lob - @Size(max = 2147483647) - @Column(name = "description") - private String description; - @Lob - @Size(max = 2147483647) - @Column(name = "scope") - private String scope; - @JoinColumns({ - @JoinColumn(name = "requirement_spec_id", referencedColumnName = "id", - insertable = false, updatable = false) - , @JoinColumn(name = "requirement_spec_project_id", - referencedColumnName = "project_id", insertable = false, - updatable = false) - , @JoinColumn(name = "requirement_spec_spec_level_id", - referencedColumnName = "spec_level_id", insertable = false, - updatable = false)}) - @ManyToOne(optional = false) - private RequirementSpec requirementSpec; - @OneToMany(mappedBy = "requirementSpecNode") - private List requirementSpecNodeList; - @JoinColumns({ - @JoinColumn(name = "requirement_spec_node_id", - referencedColumnName = "id") - , @JoinColumn(name = "requirement_spec_node_requirement_spec_id", - referencedColumnName = "requirement_spec_id") - , @JoinColumn(name = "requirement_spec_node_requirement_spec_project_id", - referencedColumnName = "requirement_spec_project_id") - , @JoinColumn(name = "requirement_spec_node_requirement_spec_spec_level_id", - referencedColumnName = "requirement_spec_spec_level_id")}) - @ManyToOne - private RequirementSpecNode requirementSpecNode; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirementSpecNode") - private List requirementList; - - public RequirementSpecNode() { - } - - public RequirementSpecNode(RequirementSpecNodePK requirementSpecNodePK) { - this.requirementSpecNodePK = requirementSpecNodePK; - } - - public RequirementSpecNode(RequirementSpecNodePK requirementSpecNodePK, - String name) { - this.requirementSpecNodePK = requirementSpecNodePK; - this.name = name; - } - - public RequirementSpecNode(RequirementSpecPK pk) { - this.requirementSpecNodePK = new RequirementSpecNodePK(pk.getId(), - pk.getProjectId(), pk.getSpecLevelId()); - } - - public RequirementSpecNode(int requirementSpecId, - int requirementSpecProjectId, int requirementSpecSpecLevelId) { - this.requirementSpecNodePK - = new RequirementSpecNodePK(requirementSpecId, - requirementSpecProjectId, requirementSpecSpecLevelId); - } - - public RequirementSpecNodePK getRequirementSpecNodePK() { - return requirementSpecNodePK; - } - - public void setRequirementSpecNodePK(RequirementSpecNodePK requirementSpecNodePK) { - this.requirementSpecNodePK = requirementSpecNodePK; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - public String getScope() { - return scope; - } - - public void setScope(String scope) { - this.scope = scope; - } - - public RequirementSpec getRequirementSpec() { - return requirementSpec; - } - - public void setRequirementSpec(RequirementSpec requirementSpec) { - this.requirementSpec = requirementSpec; - } - - @XmlTransient - @JsonIgnore - public List getRequirementSpecNodeList() { - return requirementSpecNodeList; - } - - public void setRequirementSpecNodeList(List requirementSpecNodeList) { - this.requirementSpecNodeList = requirementSpecNodeList; - } - - public RequirementSpecNode getRequirementSpecNode() { - return requirementSpecNode; - } - - public void setRequirementSpecNode(RequirementSpecNode requirementSpecNode) { - this.requirementSpecNode = requirementSpecNode; - } - - @XmlTransient - @JsonIgnore - public List getRequirementList() { - return requirementList; - } - - public void setRequirementList(List requirementList) { - this.requirementList = requirementList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (requirementSpecNodePK != null ? requirementSpecNodePK.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RequirementSpecNode)) { - return false; - } - RequirementSpecNode other = (RequirementSpecNode) object; - return !((this.requirementSpecNodePK == null - && other.requirementSpecNodePK != null) - || (this.requirementSpecNodePK != null - && !this.requirementSpecNodePK.equals(other.requirementSpecNodePK))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RequirementSpecNode[ requirementSpecNodePK=" - + requirementSpecNodePK + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.JoinColumns; +import javax.persistence.Lob; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "requirement_spec_node") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "RequirementSpecNode.findAll", + query = "SELECT r FROM RequirementSpecNode r") + , @NamedQuery(name = "RequirementSpecNode.findById", + query = "SELECT r FROM RequirementSpecNode r WHERE r.requirementSpecNodePK.id = :id") + , @NamedQuery(name = "RequirementSpecNode.findByRequirementSpecId", + query = "SELECT r FROM RequirementSpecNode r WHERE r.requirementSpecNodePK.requirementSpecId = :requirementSpecId") + , @NamedQuery(name = "RequirementSpecNode.findByRequirementSpecProjectId", + query = "SELECT r FROM RequirementSpecNode r WHERE r.requirementSpecNodePK.requirementSpecProjectId = :requirementSpecProjectId") + , @NamedQuery(name = "RequirementSpecNode.findByRequirementSpecSpecLevelId", + query = "SELECT r FROM RequirementSpecNode r WHERE r.requirementSpecNodePK.requirementSpecSpecLevelId = :requirementSpecSpecLevelId") + , @NamedQuery(name = "RequirementSpecNode.findByName", + query = "SELECT r FROM RequirementSpecNode r WHERE r.name = :name")}) +public class RequirementSpecNode implements Serializable { + + private static final long serialVersionUID = 1L; + @EmbeddedId + protected RequirementSpecNodePK requirementSpecNodePK; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "description") + private String description; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "scope") + private String scope; + @JoinColumns({ + @JoinColumn(name = "requirement_spec_id", referencedColumnName = "id", + insertable = false, updatable = false) + , @JoinColumn(name = "requirement_spec_project_id", + referencedColumnName = "project_id", insertable = false, + updatable = false) + , @JoinColumn(name = "requirement_spec_spec_level_id", + referencedColumnName = "spec_level_id", insertable = false, + updatable = false)}) + @ManyToOne(optional = false) + private RequirementSpec requirementSpec; + @OneToMany(mappedBy = "requirementSpecNode") + private List requirementSpecNodeList; + @JoinColumns({ + @JoinColumn(name = "requirement_spec_node_id", + referencedColumnName = "id") + , @JoinColumn(name = "requirement_spec_node_requirement_spec_id", + referencedColumnName = "requirement_spec_id") + , @JoinColumn(name = "requirement_spec_node_requirement_spec_project_id", + referencedColumnName = "requirement_spec_project_id") + , @JoinColumn(name = "requirement_spec_node_requirement_spec_spec_level_id", + referencedColumnName = "requirement_spec_spec_level_id")}) + @ManyToOne + private RequirementSpecNode requirementSpecNode; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirementSpecNode") + private List requirementList; + + public RequirementSpecNode() { + } + + public RequirementSpecNode(RequirementSpecNodePK requirementSpecNodePK) { + this.requirementSpecNodePK = requirementSpecNodePK; + } + + public RequirementSpecNode(RequirementSpecNodePK requirementSpecNodePK, + String name) { + this.requirementSpecNodePK = requirementSpecNodePK; + this.name = name; + } + + public RequirementSpecNode(RequirementSpecPK pk) { + this.requirementSpecNodePK = new RequirementSpecNodePK(pk.getId(), + pk.getProjectId(), pk.getSpecLevelId()); + } + + public RequirementSpecNode(int requirementSpecId, + int requirementSpecProjectId, int requirementSpecSpecLevelId) { + this.requirementSpecNodePK + = new RequirementSpecNodePK(requirementSpecId, + requirementSpecProjectId, requirementSpecSpecLevelId); + } + + public RequirementSpecNodePK getRequirementSpecNodePK() { + return requirementSpecNodePK; + } + + public void setRequirementSpecNodePK(RequirementSpecNodePK requirementSpecNodePK) { + this.requirementSpecNodePK = requirementSpecNodePK; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public String getScope() { + return scope; + } + + public void setScope(String scope) { + this.scope = scope; + } + + public RequirementSpec getRequirementSpec() { + return requirementSpec; + } + + public void setRequirementSpec(RequirementSpec requirementSpec) { + this.requirementSpec = requirementSpec; + } + + @XmlTransient + @JsonIgnore + public List getRequirementSpecNodeList() { + return requirementSpecNodeList; + } + + public void setRequirementSpecNodeList(List requirementSpecNodeList) { + this.requirementSpecNodeList = requirementSpecNodeList; + } + + public RequirementSpecNode getRequirementSpecNode() { + return requirementSpecNode; + } + + public void setRequirementSpecNode(RequirementSpecNode requirementSpecNode) { + this.requirementSpecNode = requirementSpecNode; + } + + @XmlTransient + @JsonIgnore + public List getRequirementList() { + return requirementList; + } + + public void setRequirementList(List requirementList) { + this.requirementList = requirementList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (requirementSpecNodePK != null ? requirementSpecNodePK.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RequirementSpecNode)) { + return false; + } + RequirementSpecNode other = (RequirementSpecNode) object; + return !((this.requirementSpecNodePK == null + && other.requirementSpecNodePK != null) + || (this.requirementSpecNodePK != null + && !this.requirementSpecNodePK.equals(other.requirementSpecNodePK))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RequirementSpecNode[ requirementSpecNodePK=" + + requirementSpecNodePK + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecNodePK.java b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecNodePK.java index 2f76c9b8..fdad1f04 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecNodePK.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecNodePK.java @@ -13,125 +13,125 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Embeddable; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Embeddable -public class RequirementSpecNodePK implements Serializable { - - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "RequirementSpecNodeGen") - @TableGenerator(name = "RequirementSpecNodeGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "requirement_spec_node", - allocationSize = 1, - initialValue = 1000) - @NotNull - @Column(name = "id") - private int id; - @Basic(optional = false) - @NotNull - @Column(name = "requirement_spec_id") - private int requirementSpecId; - @Basic(optional = false) - @NotNull - @Column(name = "requirement_spec_project_id") - private int requirementSpecProjectId; - @Basic(optional = false) - @NotNull - @Column(name = "requirement_spec_spec_level_id") - private int requirementSpecSpecLevelId; - - public RequirementSpecNodePK() { - } - - public RequirementSpecNodePK(int requirementSpecId, - int requirementSpecProjectId, int requirementSpecSpecLevelId) { - this.requirementSpecId = requirementSpecId; - this.requirementSpecProjectId = requirementSpecProjectId; - this.requirementSpecSpecLevelId = requirementSpecSpecLevelId; - } - - public int getId() { - return id; - } - - public void setId(int id) { - this.id = id; - } - - public int getRequirementSpecId() { - return requirementSpecId; - } - - public void setRequirementSpecId(int requirementSpecId) { - this.requirementSpecId = requirementSpecId; - } - - public int getRequirementSpecProjectId() { - return requirementSpecProjectId; - } - - public void setRequirementSpecProjectId(int requirementSpecProjectId) { - this.requirementSpecProjectId = requirementSpecProjectId; - } - - public int getRequirementSpecSpecLevelId() { - return requirementSpecSpecLevelId; - } - - public void setRequirementSpecSpecLevelId(int requirementSpecSpecLevelId) { - this.requirementSpecSpecLevelId = requirementSpecSpecLevelId; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (int) id; - hash += (int) requirementSpecId; - hash += (int) requirementSpecProjectId; - hash += (int) requirementSpecSpecLevelId; - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RequirementSpecNodePK)) { - return false; - } - RequirementSpecNodePK other = (RequirementSpecNodePK) object; - if (this.id != other.id) { - return false; - } - if (this.requirementSpecId != other.requirementSpecId) { - return false; - } - if (this.requirementSpecProjectId != other.requirementSpecProjectId) { - return false; - } - return this.requirementSpecSpecLevelId == other.requirementSpecSpecLevelId; - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RequirementSpecNodePK[ id=" - + id + ", requirementSpecId=" + requirementSpecId - + ", requirementSpecProjectId=" + requirementSpecProjectId - + ", requirementSpecSpecLevelId=" + requirementSpecSpecLevelId + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Embeddable; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Embeddable +public class RequirementSpecNodePK implements Serializable { + + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "RequirementSpecNodeGen") + @TableGenerator(name = "RequirementSpecNodeGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "requirement_spec_node", + allocationSize = 1, + initialValue = 1_000) + @NotNull + @Column(name = "id") + private int id; + @Basic(optional = false) + @NotNull + @Column(name = "requirement_spec_id") + private int requirementSpecId; + @Basic(optional = false) + @NotNull + @Column(name = "requirement_spec_project_id") + private int requirementSpecProjectId; + @Basic(optional = false) + @NotNull + @Column(name = "requirement_spec_spec_level_id") + private int requirementSpecSpecLevelId; + + public RequirementSpecNodePK() { + } + + public RequirementSpecNodePK(int requirementSpecId, + int requirementSpecProjectId, int requirementSpecSpecLevelId) { + this.requirementSpecId = requirementSpecId; + this.requirementSpecProjectId = requirementSpecProjectId; + this.requirementSpecSpecLevelId = requirementSpecSpecLevelId; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public int getRequirementSpecId() { + return requirementSpecId; + } + + public void setRequirementSpecId(int requirementSpecId) { + this.requirementSpecId = requirementSpecId; + } + + public int getRequirementSpecProjectId() { + return requirementSpecProjectId; + } + + public void setRequirementSpecProjectId(int requirementSpecProjectId) { + this.requirementSpecProjectId = requirementSpecProjectId; + } + + public int getRequirementSpecSpecLevelId() { + return requirementSpecSpecLevelId; + } + + public void setRequirementSpecSpecLevelId(int requirementSpecSpecLevelId) { + this.requirementSpecSpecLevelId = requirementSpecSpecLevelId; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (int) id; + hash += (int) requirementSpecId; + hash += (int) requirementSpecProjectId; + hash += (int) requirementSpecSpecLevelId; + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RequirementSpecNodePK)) { + return false; + } + RequirementSpecNodePK other = (RequirementSpecNodePK) object; + if (this.id != other.id) { + return false; + } + if (this.requirementSpecId != other.requirementSpecId) { + return false; + } + if (this.requirementSpecProjectId != other.requirementSpecProjectId) { + return false; + } + return this.requirementSpecSpecLevelId == other.requirementSpecSpecLevelId; + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RequirementSpecNodePK[ id=" + + id + ", requirementSpecId=" + requirementSpecId + + ", requirementSpecProjectId=" + requirementSpecProjectId + + ", requirementSpecSpecLevelId=" + requirementSpecSpecLevelId + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecPK.java b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecPK.java index 73396a14..df54ea48 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecPK.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementSpecPK.java @@ -13,105 +13,105 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Embeddable; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Embeddable -public class RequirementSpecPK implements Serializable { - - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, generator = "ReqSpecGen") - @TableGenerator(name = "ReqSpecGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "requirement_spec", - allocationSize = 1, - initialValue = 1000) - @NotNull - @Column(name = "id") - private int id; - @Basic(optional = false) - @NotNull - @Column(name = "project_id") - private int projectId; - @Basic(optional = false) - @NotNull - @Column(name = "spec_level_id") - private int specLevelId; - - public RequirementSpecPK() { - } - - public RequirementSpecPK(int projectId, int specLevelId) { - this.projectId = projectId; - this.specLevelId = specLevelId; - } - - public int getId() { - return id; - } - - public void setId(int id) { - this.id = id; - } - - public int getProjectId() { - return projectId; - } - - public void setProjectId(int projectId) { - this.projectId = projectId; - } - - public int getSpecLevelId() { - return specLevelId; - } - - public void setSpecLevelId(int specLevelId) { - this.specLevelId = specLevelId; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (int) id; - hash += (int) projectId; - hash += (int) specLevelId; - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RequirementSpecPK)) { - return false; - } - RequirementSpecPK other = (RequirementSpecPK) object; - if (this.id != other.id) { - return false; - } - if (this.projectId != other.projectId) { - return false; - } - return this.specLevelId == other.specLevelId; - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RequirementSpecPK[ id=" + id - + ", projectId=" + projectId + ", specLevelId=" + specLevelId + " ]"; - } - -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Embeddable; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Embeddable +public class RequirementSpecPK implements Serializable { + + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, generator = "ReqSpecGen") + @TableGenerator(name = "ReqSpecGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "requirement_spec", + allocationSize = 1, + initialValue = 1_000) + @NotNull + @Column(name = "id") + private int id; + @Basic(optional = false) + @NotNull + @Column(name = "project_id") + private int projectId; + @Basic(optional = false) + @NotNull + @Column(name = "spec_level_id") + private int specLevelId; + + public RequirementSpecPK() { + } + + public RequirementSpecPK(int projectId, int specLevelId) { + this.projectId = projectId; + this.specLevelId = specLevelId; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public int getProjectId() { + return projectId; + } + + public void setProjectId(int projectId) { + this.projectId = projectId; + } + + public int getSpecLevelId() { + return specLevelId; + } + + public void setSpecLevelId(int specLevelId) { + this.specLevelId = specLevelId; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (int) id; + hash += (int) projectId; + hash += (int) specLevelId; + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RequirementSpecPK)) { + return false; + } + RequirementSpecPK other = (RequirementSpecPK) object; + if (this.id != other.id) { + return false; + } + if (this.projectId != other.projectId) { + return false; + } + return this.specLevelId == other.specLevelId; + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RequirementSpecPK[ id=" + id + + ", projectId=" + projectId + ", specLevelId=" + specLevelId + " ]"; + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementStatus.java b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementStatus.java index 9c2cd3c9..87c14762 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementStatus.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementStatus.java @@ -13,118 +13,118 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "requirement_status") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "RequirementStatus.findAll", - query = "SELECT r FROM RequirementStatus r") - , @NamedQuery(name = "RequirementStatus.findById", - query = "SELECT r FROM RequirementStatus r WHERE r.id = :id") - , @NamedQuery(name = "RequirementStatus.findByStatus", - query = "SELECT r FROM RequirementStatus r WHERE r.status = :status")}) -public class RequirementStatus implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "ReqStatusGen") - @TableGenerator(name = "ReqStatusGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "requirement_status", - allocationSize = 1, - initialValue = 1000) - @Basic(optional = false) - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "status") - private String status; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirementStatusId") - private List requirementList; - - public RequirementStatus() { - } - - public RequirementStatus(String status) { - this.status = status; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getStatus() { - return status; - } - - public void setStatus(String status) { - this.status = status; - } - - @XmlTransient - @JsonIgnore - public List getRequirementList() { - return requirementList; - } - - public void setRequirementList(List requirementList) { - this.requirementList = requirementList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RequirementStatus)) { - return false; - } - RequirementStatus other = (RequirementStatus) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RequirementStatus[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "requirement_status") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "RequirementStatus.findAll", + query = "SELECT r FROM RequirementStatus r") + , @NamedQuery(name = "RequirementStatus.findById", + query = "SELECT r FROM RequirementStatus r WHERE r.id = :id") + , @NamedQuery(name = "RequirementStatus.findByStatus", + query = "SELECT r FROM RequirementStatus r WHERE r.status = :status")}) +public class RequirementStatus implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "ReqStatusGen") + @TableGenerator(name = "ReqStatusGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "requirement_status", + allocationSize = 1, + initialValue = 1_000) + @Basic(optional = false) + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "status") + private String status; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirementStatusId") + private List requirementList; + + public RequirementStatus() { + } + + public RequirementStatus(String status) { + this.status = status; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getStatus() { + return status; + } + + public void setStatus(String status) { + this.status = status; + } + + @XmlTransient + @JsonIgnore + public List getRequirementList() { + return requirementList; + } + + public void setRequirementList(List requirementList) { + this.requirementList = requirementList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RequirementStatus)) { + return false; + } + RequirementStatus other = (RequirementStatus) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RequirementStatus[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementType.java b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementType.java index ea37099e..1a1b185a 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RequirementType.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RequirementType.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,153 +13,153 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "requirement_type") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "RequirementType.findAll", - query = "SELECT r FROM RequirementType r") - , @NamedQuery(name = "RequirementType.findById", - query = "SELECT r FROM RequirementType r WHERE r.id = :id") - , @NamedQuery(name = "RequirementType.findByName", - query = "SELECT r FROM RequirementType r WHERE r.name = :name") - , @NamedQuery(name = "RequirementType.findByDescription", - query = "SELECT r FROM RequirementType r WHERE " - + "r.description = :description")}) -public class RequirementType implements Serializable { - - @Basic(optional = false) - @NotNull - @Column(name = "level") - private int level; - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "ReqTypeGen") - @TableGenerator(name = "ReqType", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "requirement_type", - allocationSize = 1, - initialValue = 1000) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Size(max = 255) - @Column(name = "description") - private String description; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirementTypeId") - private List requirementList; - - public RequirementType() { - super(); - } - - public RequirementType(String name) { - super(); - this.name = name; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getRequirementList() { - return requirementList; - } - - public void setRequirementList(List requirementList) { - this.requirementList = requirementList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RequirementType)) { - return false; - } - RequirementType other = (RequirementType) object; - return !this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RequirementType[ id=" + id + " ]"; - } - - /** - * @return the level - */ - public int getLevel() { - return level; - } - - /** - * @param level the level to set - */ - public void setLevel(int level) { - this.level = level; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "requirement_type") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "RequirementType.findAll", + query = "SELECT r FROM RequirementType r") + , @NamedQuery(name = "RequirementType.findById", + query = "SELECT r FROM RequirementType r WHERE r.id = :id") + , @NamedQuery(name = "RequirementType.findByName", + query = "SELECT r FROM RequirementType r WHERE r.name = :name") + , @NamedQuery(name = "RequirementType.findByDescription", + query = "SELECT r FROM RequirementType r WHERE " + + "r.description = :description")}) +public class RequirementType implements Serializable { + + @Basic(optional = false) + @NotNull + @Column(name = "level") + private int level; + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "ReqTypeGen") + @TableGenerator(name = "ReqTypeGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "requirement_type", + allocationSize = 1, + initialValue = 1_000) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Size(max = 255) + @Column(name = "description") + private String description; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "requirementTypeId") + private List requirementList; + + public RequirementType() { + super(); + } + + public RequirementType(String name) { + super(); + this.name = name; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getRequirementList() { + return requirementList; + } + + public void setRequirementList(List requirementList) { + this.requirementList = requirementList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RequirementType)) { + return false; + } + RequirementType other = (RequirementType) object; + return !this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RequirementType[ id=" + id + " ]"; + } + + /** + * @return the level + */ + public int getLevel() { + return level; + } + + /** + * @param level the level to set + */ + public void setLevel(int level) { + this.level = level; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RiskCategory.java b/VM-Core/src/main/java/com/validation/manager/core/db/RiskCategory.java index 96f1c92d..c3db294c 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RiskCategory.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RiskCategory.java @@ -13,160 +13,160 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.ManyToMany; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "risk_category") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "RiskCategory.findAll", - query = "SELECT r FROM RiskCategory r") - , @NamedQuery(name = "RiskCategory.findById", - query = "SELECT r FROM RiskCategory r WHERE r.id = :id") - , @NamedQuery(name = "RiskCategory.findByName", - query = "SELECT r FROM RiskCategory r WHERE r.name = :name") - , @NamedQuery(name = "RiskCategory.findByMinimum", - query = "SELECT r FROM RiskCategory r WHERE r.minimum = :minimum") - , @NamedQuery(name = "RiskCategory.findByMaximum", - query = "SELECT r FROM RiskCategory r WHERE r.maximum = :maximum")}) -public class RiskCategory implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @GeneratedValue(strategy = GenerationType.TABLE, generator = "RCGen") - @TableGenerator(name = "RCGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "risk_category", - allocationSize = 1, - initialValue = 1000) - @Basic(optional = false) - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 45) - @Column(name = "name") - private String name; - @Basic(optional = false) - @NotNull - @Column(name = "minimum") - private int minimum; - @Basic(optional = false) - @NotNull - @Column(name = "maximum") - private int maximum; - @ManyToMany(mappedBy = "riskCategoryList") - private List fmeaList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "riskCategory") - private List riskItemHasRiskCategoryList; - - public RiskCategory() { - } - - public RiskCategory(String name, int minimum, int maximum) { - this.name = name; - this.minimum = minimum; - this.maximum = maximum; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public int getMinimum() { - return minimum; - } - - public void setMinimum(int minimum) { - this.minimum = minimum; - } - - public int getMaximum() { - return maximum; - } - - public void setMaximum(int maximum) { - this.maximum = maximum; - } - - @XmlTransient - @JsonIgnore - public List getFmeaList() { - return fmeaList; - } - - public void setFmeaList(List fmeaList) { - this.fmeaList = fmeaList; - } - - @XmlTransient - @JsonIgnore - public List getRiskItemHasRiskCategoryList() { - return riskItemHasRiskCategoryList; - } - - public void setRiskItemHasRiskCategoryList(List riskItemHasRiskCategoryList) { - this.riskItemHasRiskCategoryList = riskItemHasRiskCategoryList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RiskCategory)) { - return false; - } - RiskCategory other = (RiskCategory) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RiskCategory[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.ManyToMany; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "risk_category") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "RiskCategory.findAll", + query = "SELECT r FROM RiskCategory r") + , @NamedQuery(name = "RiskCategory.findById", + query = "SELECT r FROM RiskCategory r WHERE r.id = :id") + , @NamedQuery(name = "RiskCategory.findByName", + query = "SELECT r FROM RiskCategory r WHERE r.name = :name") + , @NamedQuery(name = "RiskCategory.findByMinimum", + query = "SELECT r FROM RiskCategory r WHERE r.minimum = :minimum") + , @NamedQuery(name = "RiskCategory.findByMaximum", + query = "SELECT r FROM RiskCategory r WHERE r.maximum = :maximum")}) +public class RiskCategory implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @GeneratedValue(strategy = GenerationType.TABLE, generator = "RCGen") + @TableGenerator(name = "RCGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "risk_category", + allocationSize = 1, + initialValue = 1_000) + @Basic(optional = false) + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 45) + @Column(name = "name") + private String name; + @Basic(optional = false) + @NotNull + @Column(name = "minimum") + private int minimum; + @Basic(optional = false) + @NotNull + @Column(name = "maximum") + private int maximum; + @ManyToMany(mappedBy = "riskCategoryList") + private List fmeaList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "riskCategory") + private List riskItemHasRiskCategoryList; + + public RiskCategory() { + } + + public RiskCategory(String name, int minimum, int maximum) { + this.name = name; + this.minimum = minimum; + this.maximum = maximum; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getMinimum() { + return minimum; + } + + public void setMinimum(int minimum) { + this.minimum = minimum; + } + + public int getMaximum() { + return maximum; + } + + public void setMaximum(int maximum) { + this.maximum = maximum; + } + + @XmlTransient + @JsonIgnore + public List getFmeaList() { + return fmeaList; + } + + public void setFmeaList(List fmeaList) { + this.fmeaList = fmeaList; + } + + @XmlTransient + @JsonIgnore + public List getRiskItemHasRiskCategoryList() { + return riskItemHasRiskCategoryList; + } + + public void setRiskItemHasRiskCategoryList(List riskItemHasRiskCategoryList) { + this.riskItemHasRiskCategoryList = riskItemHasRiskCategoryList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RiskCategory)) { + return false; + } + RiskCategory other = (RiskCategory) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RiskCategory[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RiskControlPK.java b/VM-Core/src/main/java/com/validation/manager/core/db/RiskControlPK.java index 0c1492a0..e9dd0147 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RiskControlPK.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RiskControlPK.java @@ -13,87 +13,87 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Embeddable; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Embeddable -public class RiskControlPK implements Serializable { - - @Basic(optional = false) - @NotNull - @Column(name = "id") - @GeneratedValue(strategy = GenerationType.TABLE, generator = "RiskCGen") - @TableGenerator(name = "RiskCGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "risk_control", - allocationSize = 1, - initialValue = 1000) - private int id; - @Basic(optional = false) - @NotNull - @Column(name = "risk_control_type_id") - private int riskControlTypeId; - - public RiskControlPK() { - } - - public RiskControlPK(int riskControlTypeId) { - this.riskControlTypeId = riskControlTypeId; - } - - public int getId() { - return id; - } - - public void setId(int id) { - this.id = id; - } - - public int getRiskControlTypeId() { - return riskControlTypeId; - } - - public void setRiskControlTypeId(int riskControlTypeId) { - this.riskControlTypeId = riskControlTypeId; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (int) id; - hash += (int) riskControlTypeId; - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RiskControlPK)) { - return false; - } - RiskControlPK other = (RiskControlPK) object; - if (this.id != other.id) { - return false; - } - return this.riskControlTypeId == other.riskControlTypeId; - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RiskControlPK[ id=" + id - + ", riskControlTypeId=" + riskControlTypeId + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Embeddable; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Embeddable +public class RiskControlPK implements Serializable { + + @Basic(optional = false) + @NotNull + @Column(name = "id") + @GeneratedValue(strategy = GenerationType.TABLE, generator = "RiskCGen") + @TableGenerator(name = "RiskCGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "risk_control", + allocationSize = 1, + initialValue = 1_000) + private int id; + @Basic(optional = false) + @NotNull + @Column(name = "risk_control_type_id") + private int riskControlTypeId; + + public RiskControlPK() { + } + + public RiskControlPK(int riskControlTypeId) { + this.riskControlTypeId = riskControlTypeId; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public int getRiskControlTypeId() { + return riskControlTypeId; + } + + public void setRiskControlTypeId(int riskControlTypeId) { + this.riskControlTypeId = riskControlTypeId; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (int) id; + hash += (int) riskControlTypeId; + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RiskControlPK)) { + return false; + } + RiskControlPK other = (RiskControlPK) object; + if (this.id != other.id) { + return false; + } + return this.riskControlTypeId == other.riskControlTypeId; + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RiskControlPK[ id=" + id + + ", riskControlTypeId=" + riskControlTypeId + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RiskControlType.java b/VM-Core/src/main/java/com/validation/manager/core/db/RiskControlType.java index 3a25038c..1fc3a017 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RiskControlType.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RiskControlType.java @@ -13,134 +13,134 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.Lob; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "risk_control_type") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "RiskControlType.findAll", - query = "SELECT r FROM RiskControlType r") - , @NamedQuery(name = "RiskControlType.findById", - query = "SELECT r FROM RiskControlType r WHERE r.id = :id") - , @NamedQuery(name = "RiskControlType.findByName", - query = "SELECT r FROM RiskControlType r WHERE r.name = :name")}) -public class RiskControlType implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "RiskControlTypeGen") - @TableGenerator(name = "RiskControlTypeGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "risk_control_type", - allocationSize = 1, - initialValue = 1000) - @Basic(optional = false) - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Basic(optional = false) - @NotNull - @Lob - @Size(max = 2147483647) - @Column(name = "description") - private String description; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "riskControlType") - private List riskControlList; - - public RiskControlType() { - } - - public RiskControlType(String name, String description) { - this.name = name; - this.description = description; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getRiskControlList() { - return riskControlList; - } - - public void setRiskControlList(List riskControlList) { - this.riskControlList = riskControlList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RiskControlType)) { - return false; - } - RiskControlType other = (RiskControlType) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RiskControlType[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "risk_control_type") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "RiskControlType.findAll", + query = "SELECT r FROM RiskControlType r") + , @NamedQuery(name = "RiskControlType.findById", + query = "SELECT r FROM RiskControlType r WHERE r.id = :id") + , @NamedQuery(name = "RiskControlType.findByName", + query = "SELECT r FROM RiskControlType r WHERE r.name = :name")}) +public class RiskControlType implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "RiskControlTypeGen") + @TableGenerator(name = "RiskControlTypeGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "risk_control_type", + allocationSize = 1, + initialValue = 1_000) + @Basic(optional = false) + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Basic(optional = false) + @NotNull + @Lob + @Size(max = 2_147_483_647) + @Column(name = "description") + private String description; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "riskControlType") + private List riskControlList; + + public RiskControlType() { + } + + public RiskControlType(String name, String description) { + this.name = name; + this.description = description; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getRiskControlList() { + return riskControlList; + } + + public void setRiskControlList(List riskControlList) { + this.riskControlList = riskControlList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RiskControlType)) { + return false; + } + RiskControlType other = (RiskControlType) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RiskControlType[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RiskItemPK.java b/VM-Core/src/main/java/com/validation/manager/core/db/RiskItemPK.java index 56185f60..48d6e758 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RiskItemPK.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RiskItemPK.java @@ -13,86 +13,86 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Embeddable; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Embeddable -public class RiskItemPK implements Serializable { - - @Basic(optional = false) - @Column(name = "id") - @GeneratedValue(strategy = GenerationType.TABLE, generator = "RIGen") - @TableGenerator(name = "RIGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "risk_item", - allocationSize = 1, - initialValue = 1000) - private int id; - @Basic(optional = false) - @NotNull - @Column(name = "FMEA_id") - private int fMEAid; - - public RiskItemPK() { - } - - public RiskItemPK(int fMEAid) { - this.fMEAid = fMEAid; - } - - public int getId() { - return id; - } - - public void setId(int id) { - this.id = id; - } - - public int getFMEAid() { - return fMEAid; - } - - public void setFMEAid(int fMEAid) { - this.fMEAid = fMEAid; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (int) id; - hash += (int) fMEAid; - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RiskItemPK)) { - return false; - } - RiskItemPK other = (RiskItemPK) object; - if (this.id != other.id) { - return false; - } - return this.fMEAid == other.fMEAid; - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RiskItemPK[ id=" + id - + ", fMEAid=" + fMEAid + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Embeddable; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Embeddable +public class RiskItemPK implements Serializable { + + @Basic(optional = false) + @Column(name = "id") + @GeneratedValue(strategy = GenerationType.TABLE, generator = "RIGen") + @TableGenerator(name = "RIGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "risk_item", + allocationSize = 1, + initialValue = 1_000) + private int id; + @Basic(optional = false) + @NotNull + @Column(name = "FMEA_id") + private int fMEAid; + + public RiskItemPK() { + } + + public RiskItemPK(int fMEAid) { + this.fMEAid = fMEAid; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public int getFMEAid() { + return fMEAid; + } + + public void setFMEAid(int fMEAid) { + this.fMEAid = fMEAid; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (int) id; + hash += (int) fMEAid; + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RiskItemPK)) { + return false; + } + RiskItemPK other = (RiskItemPK) object; + if (this.id != other.id) { + return false; + } + return this.fMEAid == other.fMEAid; + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RiskItemPK[ id=" + id + + ", fMEAid=" + fMEAid + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Role.java b/VM-Core/src/main/java/com/validation/manager/core/db/Role.java index 20c2f5b7..2ceab0b1 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Role.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Role.java @@ -13,185 +13,185 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "role") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Role.findAll", query = "SELECT r FROM Role r") - , @NamedQuery(name = "Role.findById", - query = "SELECT r FROM Role r WHERE r.id = :id") - , @NamedQuery(name = "Role.findByName", - query = "SELECT r FROM Role r WHERE r.roleName = :name")}) -public class Role implements Serializable { - - private static final long serialVersionUID = 1L; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "role") - private List executionStepHasVmUserList; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, generator = "RoleGen") - @TableGenerator(name = "RoleGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "role", - allocationSize = 1, - initialValue = 1000) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "role_name") - private String roleName; - @Lob - @Size(max = 65535) - @Column(name = "description") - private String description; - @JoinTable(name = "user_has_role", joinColumns = { - @JoinColumn(name = "role_id", referencedColumnName = "id")}, - inverseJoinColumns = { - @JoinColumn(name = "user_id", referencedColumnName = "id")}) - @ManyToMany - private List vmUserList; - @ManyToMany(mappedBy = "roleList") - private List userRightList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "role") - private List userTestProjectRoleList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "role") - private List userTestPlanRoleList; - - public Role() { - } - - public Role(String description) { - this.description = description; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getRoleName() { - return roleName; - } - - public void setRoleName(String roleName) { - this.roleName = roleName; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getVmUserList() { - return vmUserList; - } - - public void setVmUserList(List vmUserList) { - this.vmUserList = vmUserList; - } - - @XmlTransient - @JsonIgnore - public List getUserRightList() { - return userRightList; - } - - public void setUserRightList(List userRightList) { - this.userRightList = userRightList; - } - - @XmlTransient - @JsonIgnore - public List getUserTestProjectRoleList() { - return userTestProjectRoleList; - } - - public void setUserTestProjectRoleList(List userTestProjectRoleList) { - this.userTestProjectRoleList = userTestProjectRoleList; - } - - @XmlTransient - @JsonIgnore - public List getUserTestPlanRoleList() { - return userTestPlanRoleList; - } - - public void setUserTestPlanRoleList(List userTestPlanRoleList) { - this.userTestPlanRoleList = userTestPlanRoleList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof Role)) { - return false; - } - Role other = (Role) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Role[ id=" + id + " ]"; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepHasVmUserList() { - return executionStepHasVmUserList; - } - - public void setExecutionStepHasVmUserList(List executionStepHasVmUserList) { - this.executionStepHasVmUserList = executionStepHasVmUserList; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "role") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Role.findAll", query = "SELECT r FROM Role r") + , @NamedQuery(name = "Role.findById", + query = "SELECT r FROM Role r WHERE r.id = :id") + , @NamedQuery(name = "Role.findByName", + query = "SELECT r FROM Role r WHERE r.roleName = :name")}) +public class Role implements Serializable { + + private static final long serialVersionUID = 1L; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "role") + private List executionStepHasVmUserList; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, generator = "RoleGen") + @TableGenerator(name = "RoleGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "role", + allocationSize = 1, + initialValue = 1_000) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "role_name") + private String roleName; + @Lob + @Size(max = 65_535) + @Column(name = "description") + private String description; + @JoinTable(name = "user_has_role", joinColumns = { + @JoinColumn(name = "role_id", referencedColumnName = "id")}, + inverseJoinColumns = { + @JoinColumn(name = "user_id", referencedColumnName = "id")}) + @ManyToMany + private List vmUserList; + @ManyToMany(mappedBy = "roleList") + private List userRightList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "role") + private List userTestProjectRoleList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "role") + private List userTestPlanRoleList; + + public Role() { + } + + public Role(String description) { + this.description = description; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getRoleName() { + return roleName; + } + + public void setRoleName(String roleName) { + this.roleName = roleName; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getVmUserList() { + return vmUserList; + } + + public void setVmUserList(List vmUserList) { + this.vmUserList = vmUserList; + } + + @XmlTransient + @JsonIgnore + public List getUserRightList() { + return userRightList; + } + + public void setUserRightList(List userRightList) { + this.userRightList = userRightList; + } + + @XmlTransient + @JsonIgnore + public List getUserTestProjectRoleList() { + return userTestProjectRoleList; + } + + public void setUserTestProjectRoleList(List userTestProjectRoleList) { + this.userTestProjectRoleList = userTestProjectRoleList; + } + + @XmlTransient + @JsonIgnore + public List getUserTestPlanRoleList() { + return userTestPlanRoleList; + } + + public void setUserTestPlanRoleList(List userTestPlanRoleList) { + this.userTestPlanRoleList = userTestPlanRoleList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof Role)) { + return false; + } + Role other = (Role) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Role[ id=" + id + " ]"; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepHasVmUserList() { + return executionStepHasVmUserList; + } + + public void setExecutionStepHasVmUserList(List executionStepHasVmUserList) { + this.executionStepHasVmUserList = executionStepHasVmUserList; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RootCause.java b/VM-Core/src/main/java/com/validation/manager/core/db/RootCause.java index 212ee4fd..1536da24 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RootCause.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RootCause.java @@ -13,153 +13,153 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.EmbeddedId; -import javax.persistence.Entity; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "root_cause") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "RootCause.findAll", - query = "SELECT r FROM RootCause r") - , @NamedQuery(name = "RootCause.findById", - query = "SELECT r FROM RootCause r WHERE r.rootCausePK.id = :id") - , @NamedQuery(name = "RootCause.findByRootCauseTypeId", - query = "SELECT r FROM RootCause r WHERE " - + "r.rootCausePK.rootCauseTypeId = :rootCauseTypeId")}) -public class RootCause implements Serializable { - - private static final long serialVersionUID = 1L; - @EmbeddedId - protected RootCausePK rootCausePK; - @Basic(optional = false) - @NotNull - @Lob - @Size(max = 2147483647) - @Column(name = "details") - private String details; - @JoinTable(name = "root_cause_has_user", joinColumns = { - @JoinColumn(name = "root_cause_id", referencedColumnName = "id") - , @JoinColumn(name = "root_cause_root_cause_type_id", - referencedColumnName = "root_cause_type_id")}, - inverseJoinColumns = { - @JoinColumn(name = "vm_user_id", referencedColumnName = "id")}) - @ManyToMany - private List vmUserList; - @JoinColumn(name = "root_cause_type_id", referencedColumnName = "id", - insertable = false, updatable = false) - @ManyToOne(optional = false) - private RootCauseType rootCauseType; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "rootCause") - private List exceptionHasRootCauseList; - - public RootCause() { - } - - public RootCause(RootCausePK rootCausePK) { - this.rootCausePK = rootCausePK; - } - - public RootCause(RootCausePK rootCausePK, String details) { - this.rootCausePK = rootCausePK; - this.details = details; - } - - public RootCause(int id, int rootCauseTypeId) { - this.rootCausePK = new RootCausePK(id, rootCauseTypeId); - } - - public RootCausePK getRootCausePK() { - return rootCausePK; - } - - public void setRootCausePK(RootCausePK rootCausePK) { - this.rootCausePK = rootCausePK; - } - - public String getDetails() { - return details; - } - - public void setDetails(String details) { - this.details = details; - } - - @XmlTransient - @JsonIgnore - public List getVmUserList() { - return vmUserList; - } - - public void setVmUserList(List vmUserList) { - this.vmUserList = vmUserList; - } - - public RootCauseType getRootCauseType() { - return rootCauseType; - } - - public void setRootCauseType(RootCauseType rootCauseType) { - this.rootCauseType = rootCauseType; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (rootCausePK != null ? rootCausePK.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RootCause)) { - return false; - } - RootCause other = (RootCause) object; - return !((this.rootCausePK == null && other.rootCausePK != null) - || (this.rootCausePK != null - && !this.rootCausePK.equals(other.rootCausePK))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RootCause[ rootCausePK=" - + rootCausePK + " ]"; - } - - @XmlTransient - @JsonIgnore - public List getExceptionHasRootCauseList() { - return exceptionHasRootCauseList; - } - - public void setExceptionHasRootCauseList(List exceptionHasRootCauseList) { - this.exceptionHasRootCauseList = exceptionHasRootCauseList; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "root_cause") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "RootCause.findAll", + query = "SELECT r FROM RootCause r") + , @NamedQuery(name = "RootCause.findById", + query = "SELECT r FROM RootCause r WHERE r.rootCausePK.id = :id") + , @NamedQuery(name = "RootCause.findByRootCauseTypeId", + query = "SELECT r FROM RootCause r WHERE " + + "r.rootCausePK.rootCauseTypeId = :rootCauseTypeId")}) +public class RootCause implements Serializable { + + private static final long serialVersionUID = 1L; + @EmbeddedId + protected RootCausePK rootCausePK; + @Basic(optional = false) + @NotNull + @Lob + @Size(max = 2_147_483_647) + @Column(name = "details") + private String details; + @JoinTable(name = "root_cause_has_user", joinColumns = { + @JoinColumn(name = "root_cause_id", referencedColumnName = "id") + , @JoinColumn(name = "root_cause_root_cause_type_id", + referencedColumnName = "root_cause_type_id")}, + inverseJoinColumns = { + @JoinColumn(name = "vm_user_id", referencedColumnName = "id")}) + @ManyToMany + private List vmUserList; + @JoinColumn(name = "root_cause_type_id", referencedColumnName = "id", + insertable = false, updatable = false) + @ManyToOne(optional = false) + private RootCauseType rootCauseType; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "rootCause") + private List exceptionHasRootCauseList; + + public RootCause() { + } + + public RootCause(RootCausePK rootCausePK) { + this.rootCausePK = rootCausePK; + } + + public RootCause(RootCausePK rootCausePK, String details) { + this.rootCausePK = rootCausePK; + this.details = details; + } + + public RootCause(int id, int rootCauseTypeId) { + this.rootCausePK = new RootCausePK(id, rootCauseTypeId); + } + + public RootCausePK getRootCausePK() { + return rootCausePK; + } + + public void setRootCausePK(RootCausePK rootCausePK) { + this.rootCausePK = rootCausePK; + } + + public String getDetails() { + return details; + } + + public void setDetails(String details) { + this.details = details; + } + + @XmlTransient + @JsonIgnore + public List getVmUserList() { + return vmUserList; + } + + public void setVmUserList(List vmUserList) { + this.vmUserList = vmUserList; + } + + public RootCauseType getRootCauseType() { + return rootCauseType; + } + + public void setRootCauseType(RootCauseType rootCauseType) { + this.rootCauseType = rootCauseType; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (rootCausePK != null ? rootCausePK.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RootCause)) { + return false; + } + RootCause other = (RootCause) object; + return !((this.rootCausePK == null && other.rootCausePK != null) + || (this.rootCausePK != null + && !this.rootCausePK.equals(other.rootCausePK))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RootCause[ rootCausePK=" + + rootCausePK + " ]"; + } + + @XmlTransient + @JsonIgnore + public List getExceptionHasRootCauseList() { + return exceptionHasRootCauseList; + } + + public void setExceptionHasRootCauseList(List exceptionHasRootCauseList) { + this.exceptionHasRootCauseList = exceptionHasRootCauseList; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RootCausePK.java b/VM-Core/src/main/java/com/validation/manager/core/db/RootCausePK.java index 75f22b5d..395fd8ed 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RootCausePK.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RootCausePK.java @@ -13,88 +13,88 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Embeddable; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Embeddable -public class RootCausePK implements Serializable { - - @Basic(optional = false) - @NotNull - @Column(name = "id") - @GeneratedValue(strategy = GenerationType.TABLE, generator = "RootCGen") - @TableGenerator(name = "RootCGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "root_cause", - allocationSize = 1, - initialValue = 1000) - private int id; - @Basic(optional = false) - @NotNull - @Column(name = "root_cause_type_id") - private int rootCauseTypeId; - - public RootCausePK() { - } - - public RootCausePK(int id, int rootCauseTypeId) { - this.id = id; - this.rootCauseTypeId = rootCauseTypeId; - } - - public int getId() { - return id; - } - - public void setId(int id) { - this.id = id; - } - - public int getRootCauseTypeId() { - return rootCauseTypeId; - } - - public void setRootCauseTypeId(int rootCauseTypeId) { - this.rootCauseTypeId = rootCauseTypeId; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (int) id; - hash += (int) rootCauseTypeId; - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RootCausePK)) { - return false; - } - RootCausePK other = (RootCausePK) object; - if (this.id != other.id) { - return false; - } - return this.rootCauseTypeId == other.rootCauseTypeId; - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RootCausePK[ id=" + id - + ", rootCauseTypeId=" + rootCauseTypeId + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Embeddable; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Embeddable +public class RootCausePK implements Serializable { + + @Basic(optional = false) + @NotNull + @Column(name = "id") + @GeneratedValue(strategy = GenerationType.TABLE, generator = "RootCGen") + @TableGenerator(name = "RootCGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "root_cause", + allocationSize = 1, + initialValue = 1_000) + private int id; + @Basic(optional = false) + @NotNull + @Column(name = "root_cause_type_id") + private int rootCauseTypeId; + + public RootCausePK() { + } + + public RootCausePK(int id, int rootCauseTypeId) { + this.id = id; + this.rootCauseTypeId = rootCauseTypeId; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public int getRootCauseTypeId() { + return rootCauseTypeId; + } + + public void setRootCauseTypeId(int rootCauseTypeId) { + this.rootCauseTypeId = rootCauseTypeId; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (int) id; + hash += (int) rootCauseTypeId; + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RootCausePK)) { + return false; + } + RootCausePK other = (RootCausePK) object; + if (this.id != other.id) { + return false; + } + return this.rootCauseTypeId == other.rootCauseTypeId; + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RootCausePK[ id=" + id + + ", rootCauseTypeId=" + rootCauseTypeId + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/RootCauseType.java b/VM-Core/src/main/java/com/validation/manager/core/db/RootCauseType.java index 726f6b01..78ba305e 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/RootCauseType.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/RootCauseType.java @@ -13,140 +13,140 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "root_cause_type") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "RootCauseType.findAll", - query = "SELECT r FROM RootCauseType r") - , @NamedQuery(name = "RootCauseType.findById", - query = "SELECT r FROM RootCauseType r WHERE r.id = :id") - , @NamedQuery(name = "RootCauseType.findByName", - query = "SELECT r FROM RootCauseType r WHERE r.name = :name") - , @NamedQuery(name = "RootCauseType.findByDescription", - query = "SELECT r FROM RootCauseType r WHERE r.description = :description")}) -public class RootCauseType implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @NotNull - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "RootCauseTypeGen") - @TableGenerator(name = "RootCauseTypeGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "root_cause_type", - allocationSize = 1, - initialValue = 1000) - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "description") - private String description; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "rootCauseType") - private List rootCauseList; - - public RootCauseType() { - } - - public RootCauseType(Integer id) { - this.id = id; - } - - public RootCauseType(Integer id, String name, String description) { - this.id = id; - this.name = name; - this.description = description; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getRootCauseList() { - return rootCauseList; - } - - public void setRootCauseList(List rootCauseList) { - this.rootCauseList = rootCauseList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof RootCauseType)) { - return false; - } - RootCauseType other = (RootCauseType) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.RootCauseType[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "root_cause_type") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "RootCauseType.findAll", + query = "SELECT r FROM RootCauseType r") + , @NamedQuery(name = "RootCauseType.findById", + query = "SELECT r FROM RootCauseType r WHERE r.id = :id") + , @NamedQuery(name = "RootCauseType.findByName", + query = "SELECT r FROM RootCauseType r WHERE r.name = :name") + , @NamedQuery(name = "RootCauseType.findByDescription", + query = "SELECT r FROM RootCauseType r WHERE r.description = :description")}) +public class RootCauseType implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @NotNull + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "RootCauseTypeGen") + @TableGenerator(name = "RootCauseTypeGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "root_cause_type", + allocationSize = 1, + initialValue = 1_000) + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "description") + private String description; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "rootCauseType") + private List rootCauseList; + + public RootCauseType() { + } + + public RootCauseType(Integer id) { + this.id = id; + } + + public RootCauseType(Integer id, String name, String description) { + this.id = id; + this.name = name; + this.description = description; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getRootCauseList() { + return rootCauseList; + } + + public void setRootCauseList(List rootCauseList) { + this.rootCauseList = rootCauseList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof RootCauseType)) { + return false; + } + RootCauseType other = (RootCauseType) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.RootCauseType[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/SpecLevel.java b/VM-Core/src/main/java/com/validation/manager/core/db/SpecLevel.java index bab75591..ff61abbb 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/SpecLevel.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/SpecLevel.java @@ -13,135 +13,135 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.Lob; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "spec_level") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "SpecLevel.findAll", - query = "SELECT s FROM SpecLevel s") - , @NamedQuery(name = "SpecLevel.findById", - query = "SELECT s FROM SpecLevel s WHERE s.id = :id") - , @NamedQuery(name = "SpecLevel.findByName", - query = "SELECT s FROM SpecLevel s WHERE s.name = :name")}) -public class SpecLevel implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "Spec_Level_IDGEN") - @TableGenerator(name = "Spec_Level_IDGEN", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "spec_level", - initialValue = 1000, - allocationSize = 1) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Basic(optional = false) - @NotNull - @Lob - @Size(min = 1, max = 65535) - @Column(name = "description") - private String description; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "specLevel") - private List requirementSpecList; - - public SpecLevel() { - } - - public SpecLevel(String name, String description) { - this.name = name; - this.description = description; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getRequirementSpecList() { - return requirementSpecList; - } - - public void setRequirementSpecList(List requirementSpecList) { - this.requirementSpecList = requirementSpecList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof SpecLevel)) { - return false; - } - SpecLevel other = (SpecLevel) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.SpecLevel[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "spec_level") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "SpecLevel.findAll", + query = "SELECT s FROM SpecLevel s") + , @NamedQuery(name = "SpecLevel.findById", + query = "SELECT s FROM SpecLevel s WHERE s.id = :id") + , @NamedQuery(name = "SpecLevel.findByName", + query = "SELECT s FROM SpecLevel s WHERE s.name = :name")}) +public class SpecLevel implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "Spec_Level_IDGEN") + @TableGenerator(name = "Spec_Level_IDGEN", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "spec_level", + initialValue = 1_000, + allocationSize = 1) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Basic(optional = false) + @NotNull + @Lob + @Size(min = 1, max = 65_535) + @Column(name = "description") + private String description; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "specLevel") + private List requirementSpecList; + + public SpecLevel() { + } + + public SpecLevel(String name, String description) { + this.name = name; + this.description = description; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getRequirementSpecList() { + return requirementSpecList; + } + + public void setRequirementSpecList(List requirementSpecList) { + this.requirementSpecList = requirementSpecList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof SpecLevel)) { + return false; + } + SpecLevel other = (SpecLevel) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.SpecLevel[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/Step.java b/VM-Core/src/main/java/com/validation/manager/core/db/Step.java index d99d2fbd..b8b74211 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/Step.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/Step.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,198 +13,198 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import com.validation.manager.core.history.Auditable; -import com.validation.manager.core.history.Versionable; -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.EmbeddedId; -import javax.persistence.Entity; -import javax.persistence.JoinColumn; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "step") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "Step.findAll", - query = "SELECT s FROM Step s") - , @NamedQuery(name = "Step.findById", - query = "SELECT s FROM Step s WHERE s.stepPK.id = :id") - , @NamedQuery(name = "Step.findByTestCaseId", - query = "SELECT s FROM Step s WHERE s.stepPK.testCaseId = :testCaseId") - , @NamedQuery(name = "Step.findByStepSequence", - query = "SELECT s FROM Step s WHERE s.stepSequence = :stepSequence")}) -public class Step extends Versionable implements Serializable { - - private static final long serialVersionUID = 1L; - @EmbeddedId - protected StepPK stepPK; - @Basic(optional = false) - @NotNull - @Column(name = "step_sequence") - private int stepSequence; - @Basic(optional = false) - @NotNull - @Lob - @Column(name = "text") - @Auditable - private byte[] text; - @Lob - @Column(name = "expected_result") - @Auditable - private byte[] expectedResult; - @Lob - @Size(max = 2147483647) - @Column(name = "notes") - @Auditable - private String notes; - @ManyToMany(mappedBy = "stepList") - private List requirementList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "step") - private List executionStepList; - @JoinColumn(name = "test_case_id", referencedColumnName = "id", - insertable = false, updatable = false) - @ManyToOne(optional = false) - private TestCase testCase; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "step") - private List historyList; - - public Step() { - } - - public Step(StepPK stepPK) { - this.stepPK = stepPK; - } - - public Step(StepPK stepPK, int stepSequence, byte[] text) { - this.stepPK = stepPK; - this.stepSequence = stepSequence; - this.text = text; - } - - public Step(int testCaseId) { - this.stepPK = new StepPK(testCaseId); - } - - public StepPK getStepPK() { - return stepPK; - } - - public void setStepPK(StepPK stepPK) { - this.stepPK = stepPK; - } - - public int getStepSequence() { - return stepSequence; - } - - public void setStepSequence(int stepSequence) { - this.stepSequence = stepSequence; - } - - public byte[] getExpectedResult() { - return expectedResult; - } - - public void setExpectedResult(byte[] expectedResult) { - this.expectedResult = expectedResult; - } - - public String getNotes() { - return notes; - } - - public void setNotes(String notes) { - this.notes = notes; - } - - @XmlTransient - @JsonIgnore - public List getRequirementList() { - return requirementList; - } - - public void setRequirementList(List requirementList) { - this.requirementList = requirementList; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepList() { - return executionStepList; - } - - public void setExecutionStepList(List executionStepList) { - this.executionStepList = executionStepList; - } - - public TestCase getTestCase() { - return testCase; - } - - public void setTestCase(TestCase testCase) { - this.testCase = testCase; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (stepPK != null ? stepPK.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - if (!(object instanceof Step)) { - return false; - } - Step other = (Step) object; - return !((this.stepPK == null && other.stepPK != null) - || (this.stepPK != null && !this.stepPK.equals(other.stepPK))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.Step[ stepPK=" + stepPK + " ]"; - } - - public byte[] getText() { - return text; - } - - public void setText(byte[] text) { - this.text = text; - } - - @XmlTransient - @JsonIgnore - @Override - public List getHistoryList() { - return historyList; - } - - @Override - public void setHistoryList(List historyList) { - this.historyList = historyList; - } -} +package com.validation.manager.core.db; + +import com.validation.manager.core.history.Auditable; +import com.validation.manager.core.history.Versionable; +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "step") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "Step.findAll", + query = "SELECT s FROM Step s") + , @NamedQuery(name = "Step.findById", + query = "SELECT s FROM Step s WHERE s.stepPK.id = :id") + , @NamedQuery(name = "Step.findByTestCaseId", + query = "SELECT s FROM Step s WHERE s.stepPK.testCaseId = :testCaseId") + , @NamedQuery(name = "Step.findByStepSequence", + query = "SELECT s FROM Step s WHERE s.stepSequence = :stepSequence")}) +public class Step extends Versionable implements Serializable { + + private static final long serialVersionUID = 1L; + @EmbeddedId + protected StepPK stepPK; + @Basic(optional = false) + @NotNull + @Column(name = "step_sequence") + private int stepSequence; + @Basic(optional = false) + @NotNull + @Lob + @Column(name = "text") + @Auditable + private byte[] text; + @Lob + @Column(name = "expected_result") + @Auditable + private byte[] expectedResult; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "notes") + @Auditable + private String notes; + @ManyToMany(mappedBy = "stepList") + private List requirementList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "step") + private List executionStepList; + @JoinColumn(name = "test_case_id", referencedColumnName = "id", + insertable = false, updatable = false) + @ManyToOne(optional = false) + private TestCase testCase; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "step") + private List historyList; + + public Step() { + } + + public Step(StepPK stepPK) { + this.stepPK = stepPK; + } + + public Step(StepPK stepPK, int stepSequence, byte[] text) { + this.stepPK = stepPK; + this.stepSequence = stepSequence; + this.text = text; + } + + public Step(int testCaseId) { + this.stepPK = new StepPK(testCaseId); + } + + public StepPK getStepPK() { + return stepPK; + } + + public void setStepPK(StepPK stepPK) { + this.stepPK = stepPK; + } + + public int getStepSequence() { + return stepSequence; + } + + public void setStepSequence(int stepSequence) { + this.stepSequence = stepSequence; + } + + public byte[] getExpectedResult() { + return expectedResult; + } + + public void setExpectedResult(byte[] expectedResult) { + this.expectedResult = expectedResult; + } + + public String getNotes() { + return notes; + } + + public void setNotes(String notes) { + this.notes = notes; + } + + @XmlTransient + @JsonIgnore + public List getRequirementList() { + return requirementList; + } + + public void setRequirementList(List requirementList) { + this.requirementList = requirementList; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepList() { + return executionStepList; + } + + public void setExecutionStepList(List executionStepList) { + this.executionStepList = executionStepList; + } + + public TestCase getTestCase() { + return testCase; + } + + public void setTestCase(TestCase testCase) { + this.testCase = testCase; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (stepPK != null ? stepPK.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + if (!(object instanceof Step)) { + return false; + } + Step other = (Step) object; + return !((this.stepPK == null && other.stepPK != null) + || (this.stepPK != null && !this.stepPK.equals(other.stepPK))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.Step[ stepPK=" + stepPK + " ]"; + } + + @XmlTransient + @JsonIgnore + @Override + public List getHistoryList() { + return historyList; + } + + @Override + public void setHistoryList(List historyList) { + this.historyList = historyList; + } + + public byte[] getText() { + return text; + } + + public void setText(byte[] text) { + this.text = text; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/StepPK.java b/VM-Core/src/main/java/com/validation/manager/core/db/StepPK.java index 9c9ab829..f6e1d7dc 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/StepPK.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/StepPK.java @@ -13,87 +13,87 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Embeddable; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Embeddable -public class StepPK implements Serializable { - - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, generator = "StepGen") - @TableGenerator(name = "StepGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "step", - allocationSize = 1, - initialValue = 1000) - @NotNull - @Column(name = "id") - private int id; - @Basic(optional = false) - @NotNull - @Column(name = "test_case_id") - private int testCaseId; - - public StepPK() { - } - - public StepPK(int testCaseId) { - this.testCaseId = testCaseId; - } - - public int getId() { - return id; - } - - public void setId(int id) { - this.id = id; - } - - public int getTestCaseId() { - return testCaseId; - } - - public void setTestCaseId(int testCaseId) { - this.testCaseId = testCaseId; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (int) id; - hash += (int) testCaseId; - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof StepPK)) { - return false; - } - StepPK other = (StepPK) object; - if (this.id != other.id) { - return false; - } - return this.testCaseId == other.testCaseId; - } - - @Override - public String toString() { - return "com.validation.manager.core.db.StepPK[ id=" + id - + ", testCaseId=" + testCaseId + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Embeddable; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Embeddable +public class StepPK implements Serializable { + + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, generator = "StepGen") + @TableGenerator(name = "StepGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "step", + allocationSize = 1, + initialValue = 1_000) + @NotNull + @Column(name = "id") + private int id; + @Basic(optional = false) + @NotNull + @Column(name = "test_case_id") + private int testCaseId; + + public StepPK() { + } + + public StepPK(int testCaseId) { + this.testCaseId = testCaseId; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public int getTestCaseId() { + return testCaseId; + } + + public void setTestCaseId(int testCaseId) { + this.testCaseId = testCaseId; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (int) id; + hash += (int) testCaseId; + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof StepPK)) { + return false; + } + StepPK other = (StepPK) object; + if (this.id != other.id) { + return false; + } + return this.testCaseId == other.testCaseId; + } + + @Override + public String toString() { + return "com.validation.manager.core.db.StepPK[ id=" + id + + ", testCaseId=" + testCaseId + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/TestCase.java b/VM-Core/src/main/java/com/validation/manager/core/db/TestCase.java index f22c6ad4..ef598c9d 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/TestCase.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/TestCase.java @@ -13,213 +13,213 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.Date; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "test_case") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "TestCase.findAll", - query = "SELECT t FROM TestCase t") - , @NamedQuery(name = "TestCase.findById", - query = "SELECT t FROM TestCase t WHERE t.id = :id") - , @NamedQuery(name = "TestCase.findByName", - query = "SELECT t FROM TestCase t WHERE t.name = :name") - , @NamedQuery(name = "TestCase.findByCreationDate", - query = "SELECT t FROM TestCase t WHERE t.creationDate = :creationDate") - , @NamedQuery(name = "TestCase.findByActive", - query = "SELECT t FROM TestCase t WHERE t.active = :active") - , @NamedQuery(name = "TestCase.findByIsOpen", - query = "SELECT t FROM TestCase t WHERE t.isOpen = :isOpen")}) -public class TestCase implements Serializable { - - @Lob - @Column(name = "summary") - private byte[] summary; - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @NotNull - @Column(name = "id") - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "TestCase_IDGEN") - @TableGenerator(name = "TestCase_IDGEN", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "test_case", - initialValue = 1000, - allocationSize = 1) - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Basic(optional = false) - @NotNull - @Column(name = "creation_date") - @Temporal(TemporalType.TIMESTAMP) - private Date creationDate; - @Column(name = "active") - private Boolean active; - @Column(name = "is_open") - private Boolean isOpen; - @JoinTable(name = "test_plan_has_test_case", joinColumns = { - @JoinColumn(name = "test_case_id", referencedColumnName = "id")}, - inverseJoinColumns = { - @JoinColumn(name = "test_plan_id", referencedColumnName = "id") - , @JoinColumn(name = "test_plan_test_project_id", - referencedColumnName = "test_project_id")}) - @ManyToMany - private List testPlanList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "testCase") - private List riskControlHasTestCaseList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "testCase") - private List stepList; - - public TestCase() { - } - - public TestCase(int id) { - this.id = id; - } - - public TestCase(String name, Date creationDate) { - this.name = name; - this.creationDate = creationDate; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - - public Date getCreationDate() { - return creationDate; - } - - public void setCreationDate(Date creationDate) { - this.creationDate = creationDate; - } - - public Boolean getActive() { - return active; - } - - public void setActive(Boolean active) { - this.active = active; - } - - public Boolean getIsOpen() { - return isOpen; - } - - public void setIsOpen(Boolean isOpen) { - this.isOpen = isOpen; - } - - @XmlTransient - @JsonIgnore - public List getTestPlanList() { - return testPlanList; - } - - public void setTestPlanList(List testPlanList) { - this.testPlanList = testPlanList; - } - - @XmlTransient - @JsonIgnore - public List getRiskControlHasTestCaseList() { - return riskControlHasTestCaseList; - } - - public void setRiskControlHasTestCaseList(List riskControlHasTestCaseList) { - this.riskControlHasTestCaseList = riskControlHasTestCaseList; - } - - @XmlTransient - @JsonIgnore - public List getStepList() { - return stepList; - } - - public void setStepList(List stepList) { - this.stepList = stepList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof TestCase)) { - return false; - } - TestCase other = (TestCase) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.TestCase[ id=" + id + " ]"; - } - - public byte[] getSummary() { - return summary; - } - - public void setSummary(byte[] summary) { - this.summary = summary; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.Date; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "test_case") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "TestCase.findAll", + query = "SELECT t FROM TestCase t") + , @NamedQuery(name = "TestCase.findById", + query = "SELECT t FROM TestCase t WHERE t.id = :id") + , @NamedQuery(name = "TestCase.findByName", + query = "SELECT t FROM TestCase t WHERE t.name = :name") + , @NamedQuery(name = "TestCase.findByCreationDate", + query = "SELECT t FROM TestCase t WHERE t.creationDate = :creationDate") + , @NamedQuery(name = "TestCase.findByActive", + query = "SELECT t FROM TestCase t WHERE t.active = :active") + , @NamedQuery(name = "TestCase.findByIsOpen", + query = "SELECT t FROM TestCase t WHERE t.isOpen = :isOpen")}) +public class TestCase implements Serializable { + + @Lob + @Column(name = "summary") + private byte[] summary; + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @NotNull + @Column(name = "id") + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "TestCase_IDGEN") + @TableGenerator(name = "TestCase_IDGEN", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "test_case", + initialValue = 1_000, + allocationSize = 1) + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Basic(optional = false) + @NotNull + @Column(name = "creation_date") + @Temporal(TemporalType.TIMESTAMP) + private Date creationDate; + @Column(name = "active") + private Boolean active; + @Column(name = "is_open") + private Boolean isOpen; + @JoinTable(name = "test_plan_has_test_case", joinColumns = { + @JoinColumn(name = "test_case_id", referencedColumnName = "id")}, + inverseJoinColumns = { + @JoinColumn(name = "test_plan_id", referencedColumnName = "id") + , @JoinColumn(name = "test_plan_test_project_id", + referencedColumnName = "test_project_id")}) + @ManyToMany + private List testPlanList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "testCase") + private List riskControlHasTestCaseList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "testCase") + private List stepList; + + public TestCase() { + } + + public TestCase(int id) { + this.id = id; + } + + public TestCase(String name, Date creationDate) { + this.name = name; + this.creationDate = creationDate; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + + public Date getCreationDate() { + return creationDate; + } + + public void setCreationDate(Date creationDate) { + this.creationDate = creationDate; + } + + public Boolean getActive() { + return active; + } + + public void setActive(Boolean active) { + this.active = active; + } + + public Boolean getIsOpen() { + return isOpen; + } + + public void setIsOpen(Boolean isOpen) { + this.isOpen = isOpen; + } + + @XmlTransient + @JsonIgnore + public List getTestPlanList() { + return testPlanList; + } + + public void setTestPlanList(List testPlanList) { + this.testPlanList = testPlanList; + } + + @XmlTransient + @JsonIgnore + public List getRiskControlHasTestCaseList() { + return riskControlHasTestCaseList; + } + + public void setRiskControlHasTestCaseList(List riskControlHasTestCaseList) { + this.riskControlHasTestCaseList = riskControlHasTestCaseList; + } + + @XmlTransient + @JsonIgnore + public List getStepList() { + return stepList; + } + + public void setStepList(List stepList) { + this.stepList = stepList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof TestCase)) { + return false; + } + TestCase other = (TestCase) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.TestCase[ id=" + id + " ]"; + } + + public byte[] getSummary() { + return summary; + } + + public void setSummary(byte[] summary) { + this.summary = summary; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/TestCaseExecution.java b/VM-Core/src/main/java/com/validation/manager/core/db/TestCaseExecution.java index 2f1ea4b2..bbd217db 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/TestCaseExecution.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/TestCaseExecution.java @@ -13,145 +13,145 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.Lob; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "test_case_execution") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "TestCaseExecution.findAll", - query = "SELECT t FROM TestCaseExecution t") - , @NamedQuery(name = "TestCaseExecution.findById", - query = "SELECT t FROM TestCaseExecution t WHERE t.id = :id")}) -public class TestCaseExecution implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "TestCaseExecGen") - @TableGenerator(name = "TestCaseExecGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "test_case_execution", - allocationSize = 1, - initialValue = 1000) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Lob - @Size(max = 2147483647) - @Column(name = "scope") - private String scope; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Lob - @Size(max = 2147483647) - @Column(name = "conclusion") - private String conclusion; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "testCaseExecution") - private List executionStepList; - - public TestCaseExecution(String name, String scope) { - this.name = name; - this.scope = scope; - } - - public TestCaseExecution() { - } - - public Integer getId() { - return this.id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getScope() { - return scope; - } - - public void setScope(String scope) { - this.scope = scope; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getConclusion() { - return conclusion; - } - - public void setConclusion(String conclusion) { - this.conclusion = conclusion; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepList() { - return executionStepList; - } - - public void setExecutionStepList(List executionStepList) { - this.executionStepList = executionStepList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof TestCaseExecution)) { - return false; - } - TestCaseExecution other = (TestCaseExecution) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.TestCaseExecution[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "test_case_execution") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "TestCaseExecution.findAll", + query = "SELECT t FROM TestCaseExecution t") + , @NamedQuery(name = "TestCaseExecution.findById", + query = "SELECT t FROM TestCaseExecution t WHERE t.id = :id")}) +public class TestCaseExecution implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "TestCaseExecGen") + @TableGenerator(name = "TestCaseExecGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "test_case_execution", + allocationSize = 1, + initialValue = 1_000) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Lob + @Size(max = 2_147_483_647) + @Column(name = "scope") + private String scope; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "conclusion") + private String conclusion; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "testCaseExecution") + private List executionStepList; + + public TestCaseExecution(String name, String scope) { + this.name = name; + this.scope = scope; + } + + public TestCaseExecution() { + } + + public Integer getId() { + return this.id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getScope() { + return scope; + } + + public void setScope(String scope) { + this.scope = scope; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getConclusion() { + return conclusion; + } + + public void setConclusion(String conclusion) { + this.conclusion = conclusion; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepList() { + return executionStepList; + } + + public void setExecutionStepList(List executionStepList) { + this.executionStepList = executionStepList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof TestCaseExecution)) { + return false; + } + TestCaseExecution other = (TestCaseExecution) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.TestCaseExecution[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/TestPlan.java b/VM-Core/src/main/java/com/validation/manager/core/db/TestPlan.java index cfc51caf..baa778d3 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/TestPlan.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/TestPlan.java @@ -13,212 +13,212 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.EmbeddedId; -import javax.persistence.Entity; -import javax.persistence.JoinColumn; -import javax.persistence.JoinColumns; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "test_plan") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "TestPlan.findAll", - query = "SELECT t FROM TestPlan t") - , @NamedQuery(name = "TestPlan.findById", - query = "SELECT t FROM TestPlan t WHERE t.testPlanPK.id = :id") - , @NamedQuery(name = "TestPlan.findByTestProjectId", - query = "SELECT t FROM TestPlan t WHERE t.testPlanPK.testProjectId = :testProjectId") - , @NamedQuery(name = "TestPlan.findByName", - query = "SELECT t FROM TestPlan t WHERE t.name = :name") - , @NamedQuery(name = "TestPlan.findByActive", - query = "SELECT t FROM TestPlan t WHERE t.active = :active") - , @NamedQuery(name = "TestPlan.findByIsOpen", - query = "SELECT t FROM TestPlan t WHERE t.isOpen = :isOpen")}) -public class TestPlan implements Serializable { - - private static final long serialVersionUID = 1L; - @EmbeddedId - protected TestPlanPK testPlanPK; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Lob - @Size(max = 65535) - @Column(name = "notes") - private String notes; - @Basic(optional = false) - @NotNull - @Column(name = "active") - private boolean active; - @Basic(optional = false) - @NotNull - @Column(name = "is_open") - private boolean isOpen; - @ManyToMany(mappedBy = "testPlanList") - private List testCaseList; - @OneToMany(mappedBy = "testPlan") - private List testPlanList; - @JoinColumns({ - @JoinColumn(name = "regression_test_plan_id", - referencedColumnName = "id") - , @JoinColumn(name = "regression_test_plan_test_project_id", - referencedColumnName = "test_project_id")}) - @ManyToOne - private TestPlan testPlan; - @JoinColumn(name = "test_project_id", referencedColumnName = "id", - insertable = false, updatable = false) - @ManyToOne(optional = false) - private TestProject testProject; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "testPlan") - private List userTestPlanRoleList; - - public TestPlan() { - } - - public TestPlan(TestPlanPK testPlanPK) { - this.testPlanPK = testPlanPK; - } - - public TestPlan(TestProject testProject, boolean active, boolean isOpen) { - this.testProject = testProject; - this.testPlanPK = new TestPlanPK(testProject.getId()); - this.active = active; - this.isOpen = isOpen; - } - - public TestPlanPK getTestPlanPK() { - return testPlanPK; - } - - public void setTestPlanPK(TestPlanPK testPlanPK) { - this.testPlanPK = testPlanPK; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getNotes() { - return notes; - } - - public void setNotes(String notes) { - this.notes = notes; - } - - public boolean getActive() { - return active; - } - - public void setActive(boolean active) { - this.active = active; - } - - public boolean getIsOpen() { - return isOpen; - } - - public void setIsOpen(boolean isOpen) { - this.isOpen = isOpen; - } - - @XmlTransient - @JsonIgnore - public List getTestCaseList() { - return testCaseList; - } - - public void setTestCaseList(List testCaseList) { - this.testCaseList = testCaseList; - } - - @XmlTransient - @JsonIgnore - public List getTestPlanList() { - return testPlanList; - } - - public void setTestPlanList(List testPlanList) { - this.testPlanList = testPlanList; - } - - public TestPlan getTestPlan() { - return testPlan; - } - - public void setTestPlan(TestPlan testPlan) { - this.testPlan = testPlan; - } - - public TestProject getTestProject() { - return testProject; - } - - public void setTestProject(TestProject testProject) { - this.testProject = testProject; - } - - @XmlTransient - @JsonIgnore - public List getUserTestPlanRoleList() { - return userTestPlanRoleList; - } - - public void setUserTestPlanRoleList(List userTestPlanRoleList) { - this.userTestPlanRoleList = userTestPlanRoleList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (testPlanPK != null ? testPlanPK.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof TestPlan)) { - return false; - } - TestPlan other = (TestPlan) object; - return !((this.testPlanPK == null && other.testPlanPK != null) - || (this.testPlanPK != null - && !this.testPlanPK.equals(other.testPlanPK))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.TestPlan[ testPlanPK=" - + testPlanPK + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.JoinColumns; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "test_plan") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "TestPlan.findAll", + query = "SELECT t FROM TestPlan t") + , @NamedQuery(name = "TestPlan.findById", + query = "SELECT t FROM TestPlan t WHERE t.testPlanPK.id = :id") + , @NamedQuery(name = "TestPlan.findByTestProjectId", + query = "SELECT t FROM TestPlan t WHERE t.testPlanPK.testProjectId = :testProjectId") + , @NamedQuery(name = "TestPlan.findByName", + query = "SELECT t FROM TestPlan t WHERE t.name = :name") + , @NamedQuery(name = "TestPlan.findByActive", + query = "SELECT t FROM TestPlan t WHERE t.active = :active") + , @NamedQuery(name = "TestPlan.findByIsOpen", + query = "SELECT t FROM TestPlan t WHERE t.isOpen = :isOpen")}) +public class TestPlan implements Serializable { + + private static final long serialVersionUID = 1L; + @EmbeddedId + protected TestPlanPK testPlanPK; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Lob + @Size(max = 65_535) + @Column(name = "notes") + private String notes; + @Basic(optional = false) + @NotNull + @Column(name = "active") + private boolean active; + @Basic(optional = false) + @NotNull + @Column(name = "is_open") + private boolean isOpen; + @ManyToMany(mappedBy = "testPlanList") + private List testCaseList; + @OneToMany(mappedBy = "testPlan") + private List testPlanList; + @JoinColumns({ + @JoinColumn(name = "regression_test_plan_id", + referencedColumnName = "id") + , @JoinColumn(name = "regression_test_plan_test_project_id", + referencedColumnName = "test_project_id")}) + @ManyToOne + private TestPlan testPlan; + @JoinColumn(name = "test_project_id", referencedColumnName = "id", + insertable = false, updatable = false) + @ManyToOne(optional = false) + private TestProject testProject; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "testPlan") + private List userTestPlanRoleList; + + public TestPlan() { + } + + public TestPlan(TestPlanPK testPlanPK) { + this.testPlanPK = testPlanPK; + } + + public TestPlan(TestProject testProject, boolean active, boolean isOpen) { + this.testProject = testProject; + this.testPlanPK = new TestPlanPK(testProject.getId()); + this.active = active; + this.isOpen = isOpen; + } + + public TestPlanPK getTestPlanPK() { + return testPlanPK; + } + + public void setTestPlanPK(TestPlanPK testPlanPK) { + this.testPlanPK = testPlanPK; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getNotes() { + return notes; + } + + public void setNotes(String notes) { + this.notes = notes; + } + + public boolean getActive() { + return active; + } + + public void setActive(boolean active) { + this.active = active; + } + + public boolean getIsOpen() { + return isOpen; + } + + public void setIsOpen(boolean isOpen) { + this.isOpen = isOpen; + } + + @XmlTransient + @JsonIgnore + public List getTestCaseList() { + return testCaseList; + } + + public void setTestCaseList(List testCaseList) { + this.testCaseList = testCaseList; + } + + @XmlTransient + @JsonIgnore + public List getTestPlanList() { + return testPlanList; + } + + public void setTestPlanList(List testPlanList) { + this.testPlanList = testPlanList; + } + + public TestPlan getTestPlan() { + return testPlan; + } + + public void setTestPlan(TestPlan testPlan) { + this.testPlan = testPlan; + } + + public TestProject getTestProject() { + return testProject; + } + + public void setTestProject(TestProject testProject) { + this.testProject = testProject; + } + + @XmlTransient + @JsonIgnore + public List getUserTestPlanRoleList() { + return userTestPlanRoleList; + } + + public void setUserTestPlanRoleList(List userTestPlanRoleList) { + this.userTestPlanRoleList = userTestPlanRoleList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (testPlanPK != null ? testPlanPK.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof TestPlan)) { + return false; + } + TestPlan other = (TestPlan) object; + return !((this.testPlanPK == null && other.testPlanPK != null) + || (this.testPlanPK != null + && !this.testPlanPK.equals(other.testPlanPK))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.TestPlan[ testPlanPK=" + + testPlanPK + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/TestPlanPK.java b/VM-Core/src/main/java/com/validation/manager/core/db/TestPlanPK.java index 5740b29a..84fd961a 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/TestPlanPK.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/TestPlanPK.java @@ -13,88 +13,88 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Embeddable; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Embeddable -public class TestPlanPK implements Serializable { - - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, generator = "Test_Plan_IDGEN") - @TableGenerator(name = "Test_Plan_IDGEN", - table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "test_plan", - initialValue = 1000, - allocationSize = 1) - @NotNull - @Column(name = "id") - private int id; - @Basic(optional = false) - @NotNull - @Column(name = "test_project_id") - private int testProjectId; - - public TestPlanPK() { - } - - public TestPlanPK(int testProjectId) { - this.testProjectId = testProjectId; - } - - public int getId() { - return id; - } - - public void setId(int id) { - this.id = id; - } - - public int getTestProjectId() { - return testProjectId; - } - - public void setTestProjectId(int testProjectId) { - this.testProjectId = testProjectId; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (int) id; - hash += (int) testProjectId; - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof TestPlanPK)) { - return false; - } - TestPlanPK other = (TestPlanPK) object; - if (this.id != other.id) { - return false; - } - return this.testProjectId == other.testProjectId; - } - - @Override - public String toString() { - return "com.validation.manager.core.db.TestPlanPK[ id=" + id - + ", testProjectId=" + testProjectId + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Embeddable; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Embeddable +public class TestPlanPK implements Serializable { + + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, generator = "Test_Plan_IDGEN") + @TableGenerator(name = "Test_Plan_IDGEN", + table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "test_plan", + initialValue = 1_000, + allocationSize = 1) + @NotNull + @Column(name = "id") + private int id; + @Basic(optional = false) + @NotNull + @Column(name = "test_project_id") + private int testProjectId; + + public TestPlanPK() { + } + + public TestPlanPK(int testProjectId) { + this.testProjectId = testProjectId; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public int getTestProjectId() { + return testProjectId; + } + + public void setTestProjectId(int testProjectId) { + this.testProjectId = testProjectId; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (int) id; + hash += (int) testProjectId; + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof TestPlanPK)) { + return false; + } + TestPlanPK other = (TestPlanPK) object; + if (this.id != other.id) { + return false; + } + return this.testProjectId == other.testProjectId; + } + + @Override + public String toString() { + return "com.validation.manager.core.db.TestPlanPK[ id=" + id + + ", testProjectId=" + testProjectId + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/TestProject.java b/VM-Core/src/main/java/com/validation/manager/core/db/TestProject.java index 5dd5e4ea..2beb68e4 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/TestProject.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/TestProject.java @@ -13,171 +13,171 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.Lob; -import javax.persistence.ManyToMany; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "test_project") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "TestProject.findAll", - query = "SELECT t FROM TestProject t") - , @NamedQuery(name = "TestProject.findById", - query = "SELECT t FROM TestProject t WHERE t.id = :id") - , @NamedQuery(name = "TestProject.findByName", - query = "SELECT t FROM TestProject t WHERE t.name = :name") - , @NamedQuery(name = "TestProject.findByActive", - query = "SELECT t FROM TestProject t WHERE t.active = :active")}) -public class TestProject implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @GeneratedValue(strategy = GenerationType.TABLE, generator = "TestProjectGen") - @TableGenerator(name = "TestProjectGen", table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "test_project", - allocationSize = 1, - initialValue = 1000) - @Basic(optional = false) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "name") - private String name; - @Basic(optional = false) - @NotNull - @Column(name = "active") - private boolean active; - @Lob - @Size(max = 2147483647) - @Column(name = "notes") - private String notes; - @ManyToMany(mappedBy = "testProjectList") - private List projectList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "testProject") - private List userTestProjectRoleList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "testProject") - private List testPlanList; - - public TestProject() { - } - - public TestProject(String name, boolean active) { - this.name = name; - this.active = active; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public boolean getActive() { - return active; - } - - public void setActive(boolean active) { - this.active = active; - } - - public String getNotes() { - return notes; - } - - public void setNotes(String notes) { - this.notes = notes; - } - - @XmlTransient - @JsonIgnore - public List getProjectList() { - return projectList; - } - - public void setProjectList(List projectList) { - this.projectList = projectList; - } - - @XmlTransient - @JsonIgnore - public List getUserTestProjectRoleList() { - return userTestProjectRoleList; - } - - public void setUserTestProjectRoleList(List userTestProjectRoleList) { - this.userTestProjectRoleList = userTestProjectRoleList; - } - - @XmlTransient - @JsonIgnore - public List getTestPlanList() { - return testPlanList; - } - - public void setTestPlanList(List testPlanList) { - this.testPlanList = testPlanList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof TestProject)) { - return false; - } - TestProject other = (TestProject) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.TestProject[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.ManyToMany; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "test_project") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "TestProject.findAll", + query = "SELECT t FROM TestProject t") + , @NamedQuery(name = "TestProject.findById", + query = "SELECT t FROM TestProject t WHERE t.id = :id") + , @NamedQuery(name = "TestProject.findByName", + query = "SELECT t FROM TestProject t WHERE t.name = :name") + , @NamedQuery(name = "TestProject.findByActive", + query = "SELECT t FROM TestProject t WHERE t.active = :active")}) +public class TestProject implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @GeneratedValue(strategy = GenerationType.TABLE, generator = "TestProjectGen") + @TableGenerator(name = "TestProjectGen", table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "test_project", + allocationSize = 1, + initialValue = 1_000) + @Basic(optional = false) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "name") + private String name; + @Basic(optional = false) + @NotNull + @Column(name = "active") + private boolean active; + @Lob + @Size(max = 2_147_483_647) + @Column(name = "notes") + private String notes; + @ManyToMany(mappedBy = "testProjectList") + private List projectList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "testProject") + private List userTestProjectRoleList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "testProject") + private List testPlanList; + + public TestProject() { + } + + public TestProject(String name, boolean active) { + this.name = name; + this.active = active; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public boolean getActive() { + return active; + } + + public void setActive(boolean active) { + this.active = active; + } + + public String getNotes() { + return notes; + } + + public void setNotes(String notes) { + this.notes = notes; + } + + @XmlTransient + @JsonIgnore + public List getProjectList() { + return projectList; + } + + public void setProjectList(List projectList) { + this.projectList = projectList; + } + + @XmlTransient + @JsonIgnore + public List getUserTestProjectRoleList() { + return userTestProjectRoleList; + } + + public void setUserTestProjectRoleList(List userTestProjectRoleList) { + this.userTestProjectRoleList = userTestProjectRoleList; + } + + @XmlTransient + @JsonIgnore + public List getTestPlanList() { + return testPlanList; + } + + public void setTestPlanList(List testPlanList) { + this.testPlanList = testPlanList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof TestProject)) { + return false; + } + TestProject other = (TestProject) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.TestProject[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/UserAssigmentPK.java b/VM-Core/src/main/java/com/validation/manager/core/db/UserAssigmentPK.java index 42277d09..68985775 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/UserAssigmentPK.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/UserAssigmentPK.java @@ -13,126 +13,126 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Embeddable; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Embeddable -public class UserAssigmentPK implements Serializable { - - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, - generator = "UserAssignmentGEN") - @TableGenerator(name = "UserAssignmentGEN", - table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "user_assignment", - initialValue = 1000, - allocationSize = 1) - @NotNull - @Column(name = "id") - private int id; - @Basic(optional = false) - @NotNull - @Column(name = "assigner_id") - private int assignerId; - @Basic(optional = false) - @NotNull - @Column(name = "assigment_type_id") - private int assigmentTypeId; - @Basic(optional = false) - @NotNull - @Column(name = "assignment_status_id") - private int assignmentStatusId; - - public UserAssigmentPK() { - } - - public UserAssigmentPK(int assignerId, int assigmentTypeId, - int assignmentStatusId) { - this.assignerId = assignerId; - this.assigmentTypeId = assigmentTypeId; - this.assignmentStatusId = assignmentStatusId; - } - - public int getId() { - return id; - } - - public void setId(int id) { - this.id = id; - } - - public int getAssignerId() { - return assignerId; - } - - public void setAssignerId(int assignerId) { - this.assignerId = assignerId; - } - - public int getAssigmentTypeId() { - return assigmentTypeId; - } - - public void setAssigmentTypeId(int assigmentTypeId) { - this.assigmentTypeId = assigmentTypeId; - } - - public int getAssignmentStatusId() { - return assignmentStatusId; - } - - public void setAssignmentStatusId(int assignmentStatusId) { - this.assignmentStatusId = assignmentStatusId; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (int) id; - hash += (int) assignerId; - hash += (int) assigmentTypeId; - hash += (int) assignmentStatusId; - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof UserAssigmentPK)) { - return false; - } - UserAssigmentPK other = (UserAssigmentPK) object; - if (this.id != other.id) { - return false; - } - if (this.assignerId != other.assignerId) { - return false; - } - if (this.assigmentTypeId != other.assigmentTypeId) { - return false; - } - return this.assignmentStatusId == other.assignmentStatusId; - } - - @Override - public String toString() { - return "com.validation.manager.core.db.UserAssigmentPK[ id=" + id - + ", assignerId=" + assignerId + ", assigmentTypeId=" - + assigmentTypeId + ", assignmentStatusId=" - + assignmentStatusId + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Embeddable; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Embeddable +public class UserAssigmentPK implements Serializable { + + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, + generator = "UserAssignmentGEN") + @TableGenerator(name = "UserAssignmentGEN", + table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "user_assignment", + initialValue = 1_000, + allocationSize = 1) + @NotNull + @Column(name = "id") + private int id; + @Basic(optional = false) + @NotNull + @Column(name = "assigner_id") + private int assignerId; + @Basic(optional = false) + @NotNull + @Column(name = "assigment_type_id") + private int assigmentTypeId; + @Basic(optional = false) + @NotNull + @Column(name = "assignment_status_id") + private int assignmentStatusId; + + public UserAssigmentPK() { + } + + public UserAssigmentPK(int assignerId, int assigmentTypeId, + int assignmentStatusId) { + this.assignerId = assignerId; + this.assigmentTypeId = assigmentTypeId; + this.assignmentStatusId = assignmentStatusId; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public int getAssignerId() { + return assignerId; + } + + public void setAssignerId(int assignerId) { + this.assignerId = assignerId; + } + + public int getAssigmentTypeId() { + return assigmentTypeId; + } + + public void setAssigmentTypeId(int assigmentTypeId) { + this.assigmentTypeId = assigmentTypeId; + } + + public int getAssignmentStatusId() { + return assignmentStatusId; + } + + public void setAssignmentStatusId(int assignmentStatusId) { + this.assignmentStatusId = assignmentStatusId; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (int) id; + hash += (int) assignerId; + hash += (int) assigmentTypeId; + hash += (int) assignmentStatusId; + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof UserAssigmentPK)) { + return false; + } + UserAssigmentPK other = (UserAssigmentPK) object; + if (this.id != other.id) { + return false; + } + if (this.assignerId != other.assignerId) { + return false; + } + if (this.assigmentTypeId != other.assigmentTypeId) { + return false; + } + return this.assignmentStatusId == other.assignmentStatusId; + } + + @Override + public String toString() { + return "com.validation.manager.core.db.UserAssigmentPK[ id=" + id + + ", assignerId=" + assignerId + ", assigmentTypeId=" + + assigmentTypeId + ", assignmentStatusId=" + + assignmentStatusId + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/UserRight.java b/VM-Core/src/main/java/com/validation/manager/core/db/UserRight.java index dd67004e..ffcb2bb2 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/UserRight.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/UserRight.java @@ -13,129 +13,129 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.ManyToMany; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "user_right") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "UserRight.findAll", - query = "SELECT u FROM UserRight u") - , @NamedQuery(name = "UserRight.findById", - query = "SELECT u FROM UserRight u WHERE u.id = :id") - , @NamedQuery(name = "UserRight.findByDescription", - query = "SELECT u FROM UserRight u WHERE u.description = :description")}) -public class UserRight implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, generator = "UserRightGEN") - @TableGenerator(name = "UserRightGEN", - table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "user_right", - initialValue = 1000, - allocationSize = 1) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "description") - private String description; - @JoinTable(name = "role_has_right", joinColumns = { - @JoinColumn(name = "right_id", referencedColumnName = "id")}, - inverseJoinColumns = { - @JoinColumn(name = "role_id", referencedColumnName = "id")}) - @ManyToMany - private List roleList; - - public UserRight() { - } - - public UserRight(Integer id) { - this.id = id; - } - - public UserRight(Integer id, String description) { - this.id = id; - this.description = description; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getRoleList() { - return roleList; - } - - public void setRoleList(List roleList) { - this.roleList = roleList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof UserRight)) { - return false; - } - UserRight other = (UserRight) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.UserRight[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.ManyToMany; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "user_right") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "UserRight.findAll", + query = "SELECT u FROM UserRight u") + , @NamedQuery(name = "UserRight.findById", + query = "SELECT u FROM UserRight u WHERE u.id = :id") + , @NamedQuery(name = "UserRight.findByDescription", + query = "SELECT u FROM UserRight u WHERE u.description = :description")}) +public class UserRight implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, generator = "UserRightGEN") + @TableGenerator(name = "UserRightGEN", + table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "user_right", + initialValue = 1_000, + allocationSize = 1) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "description") + private String description; + @JoinTable(name = "role_has_right", joinColumns = { + @JoinColumn(name = "right_id", referencedColumnName = "id")}, + inverseJoinColumns = { + @JoinColumn(name = "role_id", referencedColumnName = "id")}) + @ManyToMany + private List roleList; + + public UserRight() { + } + + public UserRight(Integer id) { + this.id = id; + } + + public UserRight(Integer id, String description) { + this.id = id; + this.description = description; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getRoleList() { + return roleList; + } + + public void setRoleList(List roleList) { + this.roleList = roleList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof UserRight)) { + return false; + } + UserRight other = (UserRight) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.UserRight[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/UserStatus.java b/VM-Core/src/main/java/com/validation/manager/core/db/UserStatus.java index 8176d883..8d902398 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/UserStatus.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/UserStatus.java @@ -13,132 +13,132 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "user_status") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "UserStatus.findAll", - query = "SELECT u FROM UserStatus u") - , @NamedQuery(name = "UserStatus.findById", - query = "SELECT u FROM UserStatus u WHERE u.id = :id") - , @NamedQuery(name = "UserStatus.findByStatus", - query = "SELECT u FROM UserStatus u WHERE u.status = :status") - , @NamedQuery(name = "UserStatus.findByDescription", - query = "SELECT u FROM UserStatus u WHERE u.description = :description")}) -public class UserStatus implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, generator = "UserStatusGEN") - @TableGenerator(name = "UserStatusGEN", - table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "user_status", - initialValue = 1000, - allocationSize = 1) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "status") - private String status; - @Size(max = 255) - @Column(name = "description") - private String description; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "userStatusId") - private List vmUserList; - - public UserStatus() { - } - - public UserStatus(String status) { - this.status = status; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getStatus() { - return status; - } - - public void setStatus(String status) { - this.status = status; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - @XmlTransient - @JsonIgnore - public List getVmUserList() { - return vmUserList; - } - - public void setVmUserList(List vmUserList) { - this.vmUserList = vmUserList; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof UserStatus)) { - return false; - } - UserStatus other = (UserStatus) object; - return !((this.id == null && other.id != null) - || (this.id != null && !this.id.equals(other.id))); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.UserStatus[ id=" + id + " ]"; - } -} +package com.validation.manager.core.db; + +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "user_status") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "UserStatus.findAll", + query = "SELECT u FROM UserStatus u") + , @NamedQuery(name = "UserStatus.findById", + query = "SELECT u FROM UserStatus u WHERE u.id = :id") + , @NamedQuery(name = "UserStatus.findByStatus", + query = "SELECT u FROM UserStatus u WHERE u.status = :status") + , @NamedQuery(name = "UserStatus.findByDescription", + query = "SELECT u FROM UserStatus u WHERE u.description = :description")}) +public class UserStatus implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, generator = "UserStatusGEN") + @TableGenerator(name = "UserStatusGEN", + table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "user_status", + initialValue = 1_000, + allocationSize = 1) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "status") + private String status; + @Size(max = 255) + @Column(name = "description") + private String description; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "userStatusId") + private List vmUserList; + + public UserStatus() { + } + + public UserStatus(String status) { + this.status = status; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getStatus() { + return status; + } + + public void setStatus(String status) { + this.status = status; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @XmlTransient + @JsonIgnore + public List getVmUserList() { + return vmUserList; + } + + public void setVmUserList(List vmUserList) { + this.vmUserList = vmUserList; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof UserStatus)) { + return false; + } + UserStatus other = (UserStatus) object; + return !((this.id == null && other.id != null) + || (this.id != null && !this.id.equals(other.id))); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.UserStatus[ id=" + id + " ]"; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/VmSetting.java b/VM-Core/src/main/java/com/validation/manager/core/db/VmSetting.java index d4bce094..bff702e2 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/VmSetting.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/VmSetting.java @@ -13,179 +13,179 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import com.validation.manager.core.history.Auditable; -import com.validation.manager.core.history.Versionable; -import java.io.Serializable; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.Lob; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "vm_setting") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "VmSetting.findAll", - query = "SELECT v FROM VmSetting v") - , @NamedQuery(name = "VmSetting.findById", - query = "SELECT v FROM VmSetting v WHERE v.id = :id") - , @NamedQuery(name = "VmSetting.findBySetting", - query = "SELECT v FROM VmSetting v WHERE v.setting = :setting") - , @NamedQuery(name = "VmSetting.findByBoolVal", - query = "SELECT v FROM VmSetting v WHERE v.boolVal = :boolVal") - , @NamedQuery(name = "VmSetting.findByIntVal", - query = "SELECT v FROM VmSetting v WHERE v.intVal = :intVal")}) -public class VmSetting extends Versionable implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, generator = "VM_SettingGEN") - @TableGenerator(name = "VM_SettingGEN", - table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "vm_setting", - initialValue = 1000, - allocationSize = 1) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Auditable - @Column(name = "setting") - private String setting; - @Auditable - @Column(name = "bool_val") - private Boolean boolVal; - @Auditable - @Column(name = "int_val") - private Integer intVal; - @Lob - @Size(max = 2147483647) - @Auditable - @Column(name = "long_val") - private String longVal; - @Lob - @Size(max = 2147483647) - @Auditable - @Column(name = "string_val") - private String stringVal; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmSettingId") - private List historyList; - - public VmSetting() { - } - - public VmSetting(String setting) { - this.setting = setting; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getSetting() { - return setting; - } - - public void setSetting(String setting) { - this.setting = setting; - } - - public Boolean getBoolVal() { - return boolVal; - } - - public void setBoolVal(Boolean boolVal) { - this.boolVal = boolVal; - } - - public Integer getIntVal() { - return intVal; - } - - public void setIntVal(Integer intVal) { - this.intVal = intVal; - } - - public String getLongVal() { - return longVal; - } - - public void setLongVal(String longVal) { - this.longVal = longVal; - } - - public String getStringVal() { - return stringVal; - } - - public void setStringVal(String stringVal) { - this.stringVal = stringVal; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof VmSetting)) { - return false; - } - VmSetting other = (VmSetting) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.VmSetting[ id=" + id + " ]"; - } - - @XmlTransient - @JsonIgnore - @Override - public List getHistoryList() { - return historyList; - } - - /** - * @param historyList the historyList to set - */ - @Override - public void setHistoryList(List historyList) { - this.historyList = historyList; - } -} +package com.validation.manager.core.db; + +import com.validation.manager.core.history.Auditable; +import com.validation.manager.core.history.Versionable; +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "vm_setting") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "VmSetting.findAll", + query = "SELECT v FROM VmSetting v") + , @NamedQuery(name = "VmSetting.findById", + query = "SELECT v FROM VmSetting v WHERE v.id = :id") + , @NamedQuery(name = "VmSetting.findBySetting", + query = "SELECT v FROM VmSetting v WHERE v.setting = :setting") + , @NamedQuery(name = "VmSetting.findByBoolVal", + query = "SELECT v FROM VmSetting v WHERE v.boolVal = :boolVal") + , @NamedQuery(name = "VmSetting.findByIntVal", + query = "SELECT v FROM VmSetting v WHERE v.intVal = :intVal")}) +public class VmSetting extends Versionable implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, generator = "VM_SettingGEN") + @TableGenerator(name = "VM_SettingGEN", + table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "vm_setting", + initialValue = 1_000, + allocationSize = 1) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Auditable + @Column(name = "setting") + private String setting; + @Auditable + @Column(name = "bool_val") + private Boolean boolVal; + @Auditable + @Column(name = "int_val") + private Integer intVal; + @Lob + @Size(max = 2_147_483_647) + @Auditable + @Column(name = "long_val") + private String longVal; + @Lob + @Size(max = 2_147_483_647) + @Auditable + @Column(name = "string_val") + private String stringVal; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmSettingId") + private List historyList; + + public VmSetting() { + } + + public VmSetting(String setting) { + this.setting = setting; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getSetting() { + return setting; + } + + public void setSetting(String setting) { + this.setting = setting; + } + + public Boolean getBoolVal() { + return boolVal; + } + + public void setBoolVal(Boolean boolVal) { + this.boolVal = boolVal; + } + + public Integer getIntVal() { + return intVal; + } + + public void setIntVal(Integer intVal) { + this.intVal = intVal; + } + + public String getLongVal() { + return longVal; + } + + public void setLongVal(String longVal) { + this.longVal = longVal; + } + + public String getStringVal() { + return stringVal; + } + + public void setStringVal(String stringVal) { + this.stringVal = stringVal; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof VmSetting)) { + return false; + } + VmSetting other = (VmSetting) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.VmSetting[ id=" + id + " ]"; + } + + @XmlTransient + @JsonIgnore + @Override + public List getHistoryList() { + return historyList; + } + + /** + * @param historyList the historyList to set + */ + @Override + public void setHistoryList(List historyList) { + this.historyList = historyList; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/VmUser.java b/VM-Core/src/main/java/com/validation/manager/core/db/VmUser.java index 318d00c4..e528c520 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/VmUser.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/VmUser.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,414 +13,438 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import com.validation.manager.core.history.Auditable; -import com.validation.manager.core.history.Login; -import java.io.Serializable; -import java.util.Date; -import java.util.List; -import javax.persistence.Basic; -import javax.persistence.CascadeType; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.GenerationType; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.ManyToMany; -import javax.persistence.ManyToOne; -import javax.persistence.NamedQueries; -import javax.persistence.NamedQuery; -import javax.persistence.OneToMany; -import javax.persistence.Table; -import javax.persistence.TableGenerator; -import javax.validation.constraints.NotNull; -import javax.validation.constraints.Pattern; -import javax.validation.constraints.Size; -import javax.xml.bind.annotation.XmlRootElement; -import javax.xml.bind.annotation.XmlTransient; -import org.codehaus.jackson.annotate.JsonIgnore; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@Entity -@Table(name = "vm_user") -@XmlRootElement -@NamedQueries({ - @NamedQuery(name = "VmUser.findAll", - query = "SELECT v FROM VmUser v") - , @NamedQuery(name = "VmUser.findById", - query = "SELECT v FROM VmUser v WHERE v.id = :id") - , @NamedQuery(name = "VmUser.findByUsername", - query = "SELECT v FROM VmUser v WHERE v.username = :username") - , @NamedQuery(name = "VmUser.findByPassword", - query = "SELECT v FROM VmUser v WHERE v.password = :password") - , @NamedQuery(name = "VmUser.findByEmail", - query = "SELECT v FROM VmUser v WHERE v.email = :email") - , @NamedQuery(name = "VmUser.findByFirstName", - query = "SELECT v FROM VmUser v WHERE v.firstName = :firstName") - , @NamedQuery(name = "VmUser.findByLastName", - query = "SELECT v FROM VmUser v WHERE v.lastName = :lastName") - , @NamedQuery(name = "VmUser.findByLocale", - query = "SELECT v FROM VmUser v WHERE v.locale = :locale") - , @NamedQuery(name = "VmUser.findByLastModified", - query = "SELECT v FROM VmUser v WHERE v.lastModified = :lastModified") - , @NamedQuery(name = "VmUser.findByAttempts", - query = "SELECT v FROM VmUser v WHERE v.attempts = :attempts")}) -public class VmUser extends Login implements Serializable { - - private static final long serialVersionUID = 1L; - @Id - @Basic(optional = false) - @GeneratedValue(strategy = GenerationType.TABLE, generator = "VM_UserGEN") - @TableGenerator(name = "VM_UserGEN", - table = "vm_id", - pkColumnName = "table_name", - valueColumnName = "last_id", - pkColumnValue = "vm_user", - initialValue = 1000, - allocationSize = 1) - @NotNull - @Column(name = "id") - private Integer id; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Auditable - @Column(name = "username") - private String username; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "password") - @Auditable - private String password; - @Pattern(regexp = "[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`" - + "{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:" - + "[a-z0-9-]*[a-z0-9])?", - message = "Invalid email")//if the field contains email address consider using this annotation to enforce field validation - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 100) - @Auditable - @Column(name = "email") - private String email; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "first_name") - @Auditable - private String firstName; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Column(name = "last_name") - @Auditable - private String lastName; - @Basic(optional = false) - @NotNull - @Size(min = 1, max = 255) - @Auditable - @Column(name = "locale") - private String locale; - @ManyToMany(mappedBy = "vmUserList") - private List correctiveActionList; - @ManyToMany(mappedBy = "vmUserList") - private List roleList; - @ManyToMany(mappedBy = "vmUserList") - private List rootCauseList; - @JoinColumn(name = "user_status_id", referencedColumnName = "id") - @ManyToOne(optional = false) - private UserStatus userStatusId; - @OneToMany(mappedBy = "assignee") - private List executionStepList; - @OneToMany(mappedBy = "assigner") - private List executionStepList1; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") - private List userTestProjectRoleList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") - private List userTestPlanRoleList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") - private List userModifiedRecordList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") - private List userHasInvestigationList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") - private List userAssigmentList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "assigneeId") - private List userAssigmentList1; - @ManyToMany(mappedBy = "vmUserList") - private List executionStepHasIssueList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") - private List executionStepHasVmUserList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "modifierId") - private List historyModificationList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "targetUser") - private List notificationList; - @OneToMany(cascade = CascadeType.ALL, mappedBy = "author") - private List notificationList1; - - public VmUser() { - super(); - } - - public VmUser(String username, String password, String email, String first, - String last, String locale, Date lastModified, - UserStatus userStatus, int attempts) { - this.username = username; - this.password = password; - this.email = email; - this.firstName = first; - this.lastName = last; - this.locale = locale; - this.userStatusId = userStatus; - } - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getUsername() { - return username; - } - - public void setUsername(String username) { - this.username = username; - } - - public String getPassword() { - return password; - } - - public void setPassword(String password) { - this.password = password; - } - - public String getEmail() { - return email; - } - - public void setEmail(String email) { - this.email = email; - } - - public String getFirstName() { - return firstName; - } - - public void setFirstName(String firstName) { - this.firstName = firstName; - } - - public String getLastName() { - return lastName; - } - - public void setLastName(String lastName) { - this.lastName = lastName; - } - - public String getLocale() { - return locale; - } - - public void setLocale(String locale) { - this.locale = locale; - } - - @XmlTransient - @JsonIgnore - public List getCorrectiveActionList() { - return correctiveActionList; - } - - public void setCorrectiveActionList(List correctiveActionList) { - this.correctiveActionList = correctiveActionList; - } - - @XmlTransient - @JsonIgnore - public List getRoleList() { - return roleList; - } - - public void setRoleList(List roleList) { - this.roleList = roleList; - } - - @XmlTransient - @JsonIgnore - public List getRootCauseList() { - return rootCauseList; - } - - public void setRootCauseList(List rootCauseList) { - this.rootCauseList = rootCauseList; - } - - public UserStatus getUserStatusId() { - return userStatusId; - } - - public void setUserStatusId(UserStatus userStatusId) { - this.userStatusId = userStatusId; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepList() { - return executionStepList; - } - - public void setExecutionStepList(List executionStepList) { - this.executionStepList = executionStepList; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepList1() { - return executionStepList1; - } - - public void setExecutionStepList1(List executionStepList1) { - this.executionStepList1 = executionStepList1; - } - - @XmlTransient - @JsonIgnore - public List getUserTestProjectRoleList() { - return userTestProjectRoleList; - } - - public void setUserTestProjectRoleList(List userTestProjectRoleList) { - this.userTestProjectRoleList = userTestProjectRoleList; - } - - @XmlTransient - @JsonIgnore - public List getUserTestPlanRoleList() { - return userTestPlanRoleList; - } - - public void setUserTestPlanRoleList(List userTestPlanRoleList) { - this.userTestPlanRoleList = userTestPlanRoleList; - } - - @XmlTransient - @JsonIgnore - public List getUserModifiedRecordList() { - return userModifiedRecordList; - } - - public void setUserModifiedRecordList(List userModifiedRecordList) { - this.userModifiedRecordList = userModifiedRecordList; - } - - @XmlTransient - @JsonIgnore - public List getUserHasInvestigationList() { - return userHasInvestigationList; - } - - public void setUserHasInvestigationList(List userHasInvestigationList) { - this.userHasInvestigationList = userHasInvestigationList; - } - - @XmlTransient - @JsonIgnore - public List getUserAssigmentList() { - return userAssigmentList; - } - - public void setUserAssigmentList(List userAssigmentList) { - this.userAssigmentList = userAssigmentList; - } - - @XmlTransient - @JsonIgnore - public List getUserAssigmentList1() { - return userAssigmentList1; - } - - public void setUserAssigmentList1(List userAssigmentList1) { - this.userAssigmentList1 = userAssigmentList1; - } - - @Override - public int hashCode() { - int hash = 0; - hash += (id != null ? id.hashCode() : 0); - return hash; - } - - @Override - public boolean equals(Object object) { - - if (!(object instanceof VmUser)) { - return false; - } - VmUser other = (VmUser) object; - return this.id.equals(other.id); - } - - @Override - public String toString() { - return "com.validation.manager.core.db.VmUser[ id=" + id + " ]"; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepHasIssueList() { - return executionStepHasIssueList; - } - - public void setExecutionStepHasIssueList(List executionStepHasIssueList) { - this.executionStepHasIssueList = executionStepHasIssueList; - } - - @XmlTransient - @JsonIgnore - public List getExecutionStepHasVmUserList() { - return executionStepHasVmUserList; - } - - public void setExecutionStepHasVmUserList(List executionStepHasVmUserList) { - this.executionStepHasVmUserList = executionStepHasVmUserList; - } - - @XmlTransient - @JsonIgnore - public List getHistoryModificationList() { - return historyModificationList; - } - - public void setHistoryModificationList(List historyList) { - this.historyModificationList = historyList; - } - - @XmlTransient - @JsonIgnore - public List getNotificationList() { - return notificationList; - } - - public void setNotificationList(List notificationList) { - this.notificationList = notificationList; - } - - @XmlTransient - @JsonIgnore - public List getNotificationList1() { - return notificationList1; - } - - public void setNotificationList1(List notificationList1) { - this.notificationList1 = notificationList1; - } -} +package com.validation.manager.core.db; + +import com.validation.manager.core.history.Auditable; +import com.validation.manager.core.history.Versionable; +import java.io.Serializable; +import java.util.List; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; +import javax.persistence.NamedQueries; +import javax.persistence.NamedQuery; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.TableGenerator; +import javax.validation.constraints.Min; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Pattern; +import javax.validation.constraints.Size; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlTransient; +import org.codehaus.jackson.annotate.JsonIgnore; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@Entity +@Table(name = "vm_user") +@XmlRootElement +@NamedQueries({ + @NamedQuery(name = "VmUser.findAll", + query = "SELECT v FROM VmUser v") + , @NamedQuery(name = "VmUser.findById", + query = "SELECT v FROM VmUser v WHERE v.id = :id") + , @NamedQuery(name = "VmUser.findByUsername", + query = "SELECT v FROM VmUser v WHERE v.username = :username") + , @NamedQuery(name = "VmUser.findByPassword", + query = "SELECT v FROM VmUser v WHERE v.password = :password") + , @NamedQuery(name = "VmUser.findByEmail", + query = "SELECT v FROM VmUser v WHERE v.email = :email") + , @NamedQuery(name = "VmUser.findByFirstName", + query = "SELECT v FROM VmUser v WHERE v.firstName = :firstName") + , @NamedQuery(name = "VmUser.findByLastName", + query = "SELECT v FROM VmUser v WHERE v.lastName = :lastName") + , @NamedQuery(name = "VmUser.findByLocale", + query = "SELECT v FROM VmUser v WHERE v.locale = :locale") + , @NamedQuery(name = "VmUser.findByAttempts", + query = "SELECT v FROM VmUser v WHERE v.attempts = :attempts")}) +public class VmUser extends Versionable implements Serializable { + + private static final long serialVersionUID = 1L; + @Id + @Basic(optional = false) + @GeneratedValue(strategy = GenerationType.TABLE, generator = "VM_UserGEN") + @TableGenerator(name = "VM_UserGEN", + table = "vm_id", + pkColumnName = "table_name", + valueColumnName = "last_id", + pkColumnValue = "vm_user", + initialValue = 1_000, + allocationSize = 1) + @NotNull + @Column(name = "id") + private Integer id; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Auditable + @Column(name = "username") + private String username; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "password") + @Auditable + private String password; + @Pattern(regexp = "[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`" + + "{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:" + + "[a-z0-9-]*[a-z0-9])?", + message = "Invalid email")//if the field contains email address consider using this annotation to enforce field validation + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 100) + @Auditable + @Column(name = "email") + private String email; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "first_name") + @Auditable + private String firstName; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Column(name = "last_name") + @Auditable + private String lastName; + @Basic(optional = false) + @NotNull + @Size(min = 1, max = 255) + @Auditable + @Column(name = "locale") + private String locale; + @ManyToMany(mappedBy = "vmUserList") + private List correctiveActionList; + @ManyToMany(mappedBy = "vmUserList") + private List roleList; + @ManyToMany(mappedBy = "vmUserList") + private List rootCauseList; + @JoinColumn(name = "user_status_id", referencedColumnName = "id") + @ManyToOne(optional = false) + private UserStatus userStatusId; + @OneToMany(mappedBy = "assignee") + private List executionStepList; + @OneToMany(mappedBy = "assigner") + private List executionStepList1; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") + private List userTestProjectRoleList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") + private List userTestPlanRoleList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") + private List userModifiedRecordList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") + private List userHasInvestigationList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") + private List userAssigmentList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "assigneeId") + private List userAssigmentList1; + @ManyToMany(mappedBy = "vmUserList") + private List executionStepHasIssueList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "vmUser") + private List executionStepHasVmUserList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "modifierId") + private List historyModificationList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "targetUser") + private List notificationList; + @OneToMany(cascade = CascadeType.ALL, mappedBy = "author") + private List notificationList1; + @OneToMany(mappedBy = "vmUserId") + private List historyList; + @Basic(optional = false) + @NotNull + @Column(name = "attempts") + @Min(value = 0) + private int attempts; + + public VmUser() { + super(); + } + + public VmUser(String username, String password, String email, String first, + String last, String locale, UserStatus userStatus, int attempts) { + this.username = username; + this.password = password; + this.email = email; + this.firstName = first; + this.lastName = last; + this.locale = locale; + this.userStatusId = userStatus; + } + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getUsername() { + return username; + } + + public void setUsername(String username) { + this.username = username; + } + + public String getPassword() { + return password; + } + + public void setPassword(String password) { + this.password = password; + } + + public String getEmail() { + return email; + } + + public void setEmail(String email) { + this.email = email; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public String getLastName() { + return lastName; + } + + public void setLastName(String lastName) { + this.lastName = lastName; + } + + public String getLocale() { + return locale; + } + + public void setLocale(String locale) { + this.locale = locale; + } + + @XmlTransient + @JsonIgnore + public List getCorrectiveActionList() { + return correctiveActionList; + } + + public void setCorrectiveActionList(List correctiveActionList) { + this.correctiveActionList = correctiveActionList; + } + + @XmlTransient + @JsonIgnore + public List getRoleList() { + return roleList; + } + + public void setRoleList(List roleList) { + this.roleList = roleList; + } + + @XmlTransient + @JsonIgnore + public List getRootCauseList() { + return rootCauseList; + } + + public void setRootCauseList(List rootCauseList) { + this.rootCauseList = rootCauseList; + } + + public UserStatus getUserStatusId() { + return userStatusId; + } + + public void setUserStatusId(UserStatus userStatusId) { + this.userStatusId = userStatusId; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepList() { + return executionStepList; + } + + public void setExecutionStepList(List executionStepList) { + this.executionStepList = executionStepList; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepList1() { + return executionStepList1; + } + + public void setExecutionStepList1(List executionStepList1) { + this.executionStepList1 = executionStepList1; + } + + @XmlTransient + @JsonIgnore + public List getUserTestProjectRoleList() { + return userTestProjectRoleList; + } + + public void setUserTestProjectRoleList(List userTestProjectRoleList) { + this.userTestProjectRoleList = userTestProjectRoleList; + } + + @XmlTransient + @JsonIgnore + public List getUserTestPlanRoleList() { + return userTestPlanRoleList; + } + + public void setUserTestPlanRoleList(List userTestPlanRoleList) { + this.userTestPlanRoleList = userTestPlanRoleList; + } + + @XmlTransient + @JsonIgnore + public List getUserModifiedRecordList() { + return userModifiedRecordList; + } + + public void setUserModifiedRecordList(List userModifiedRecordList) { + this.userModifiedRecordList = userModifiedRecordList; + } + + @XmlTransient + @JsonIgnore + public List getUserHasInvestigationList() { + return userHasInvestigationList; + } + + public void setUserHasInvestigationList(List userHasInvestigationList) { + this.userHasInvestigationList = userHasInvestigationList; + } + + @XmlTransient + @JsonIgnore + public List getUserAssigmentList() { + return userAssigmentList; + } + + public void setUserAssigmentList(List userAssigmentList) { + this.userAssigmentList = userAssigmentList; + } + + @XmlTransient + @JsonIgnore + public List getUserAssigmentList1() { + return userAssigmentList1; + } + + public void setUserAssigmentList1(List userAssigmentList1) { + this.userAssigmentList1 = userAssigmentList1; + } + + @Override + public int hashCode() { + int hash = 0; + hash += (id != null ? id.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object object) { + + if (!(object instanceof VmUser)) { + return false; + } + VmUser other = (VmUser) object; + return this.id.equals(other.id); + } + + @Override + public String toString() { + return "com.validation.manager.core.db.VmUser[ id=" + id + " ]"; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepHasIssueList() { + return executionStepHasIssueList; + } + + public void setExecutionStepHasIssueList(List executionStepHasIssueList) { + this.executionStepHasIssueList = executionStepHasIssueList; + } + + @XmlTransient + @JsonIgnore + public List getExecutionStepHasVmUserList() { + return executionStepHasVmUserList; + } + + public void setExecutionStepHasVmUserList(List executionStepHasVmUserList) { + this.executionStepHasVmUserList = executionStepHasVmUserList; + } + + @XmlTransient + @JsonIgnore + public List getHistoryModificationList() { + return historyModificationList; + } + + public void setHistoryModificationList(List historyList) { + this.historyModificationList = historyList; + } + + @XmlTransient + @JsonIgnore + public List getNotificationList() { + return notificationList; + } + + public void setNotificationList(List notificationList) { + this.notificationList = notificationList; + } + + @XmlTransient + @JsonIgnore + public List getNotificationList1() { + return notificationList1; + } + + public void setNotificationList1(List notificationList1) { + this.notificationList1 = notificationList1; + } + + @XmlTransient + @JsonIgnore + @Override + public List getHistoryList() { + return historyList; + } + + @Override + public void setHistoryList(List historyList) { + this.historyList = historyList; + } + + public int getAttempts() { + return attempts; + } + + public void setAttempts(int attempts) { + this.attempts = attempts; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/AssigmentTypeJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/AssigmentTypeJpaController.java index 9844a7af..9dd288ab 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/AssigmentTypeJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/AssigmentTypeJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.AssigmentType; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.UserAssigment; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class AssigmentTypeJpaController implements Serializable { - - public AssigmentTypeJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(AssigmentType assigmentType) { - if (assigmentType.getUserAssigmentList() == null) { - assigmentType.setUserAssigmentList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedUserAssigmentList = new ArrayList(); - for (UserAssigment userAssigmentListUserAssigmentToAttach : assigmentType.getUserAssigmentList()) { - userAssigmentListUserAssigmentToAttach = em.getReference(userAssigmentListUserAssigmentToAttach.getClass(), userAssigmentListUserAssigmentToAttach.getUserAssigmentPK()); - attachedUserAssigmentList.add(userAssigmentListUserAssigmentToAttach); - } - assigmentType.setUserAssigmentList(attachedUserAssigmentList); - em.persist(assigmentType); - for (UserAssigment userAssigmentListUserAssigment : assigmentType.getUserAssigmentList()) { - AssigmentType oldAssigmentTypeOfUserAssigmentListUserAssigment = userAssigmentListUserAssigment.getAssigmentType(); - userAssigmentListUserAssigment.setAssigmentType(assigmentType); - userAssigmentListUserAssigment = em.merge(userAssigmentListUserAssigment); - if (oldAssigmentTypeOfUserAssigmentListUserAssigment != null) { - oldAssigmentTypeOfUserAssigmentListUserAssigment.getUserAssigmentList().remove(userAssigmentListUserAssigment); - oldAssigmentTypeOfUserAssigmentListUserAssigment = em.merge(oldAssigmentTypeOfUserAssigmentListUserAssigment); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(AssigmentType assigmentType) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - AssigmentType persistentAssigmentType = em.find(AssigmentType.class, assigmentType.getId()); - List userAssigmentListOld = persistentAssigmentType.getUserAssigmentList(); - List userAssigmentListNew = assigmentType.getUserAssigmentList(); - List illegalOrphanMessages = null; - for (UserAssigment userAssigmentListOldUserAssigment : userAssigmentListOld) { - if (!userAssigmentListNew.contains(userAssigmentListOldUserAssigment)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserAssigment " + userAssigmentListOldUserAssigment + " since its assigmentType field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedUserAssigmentListNew = new ArrayList(); - for (UserAssigment userAssigmentListNewUserAssigmentToAttach : userAssigmentListNew) { - userAssigmentListNewUserAssigmentToAttach = em.getReference(userAssigmentListNewUserAssigmentToAttach.getClass(), userAssigmentListNewUserAssigmentToAttach.getUserAssigmentPK()); - attachedUserAssigmentListNew.add(userAssigmentListNewUserAssigmentToAttach); - } - userAssigmentListNew = attachedUserAssigmentListNew; - assigmentType.setUserAssigmentList(userAssigmentListNew); - assigmentType = em.merge(assigmentType); - for (UserAssigment userAssigmentListNewUserAssigment : userAssigmentListNew) { - if (!userAssigmentListOld.contains(userAssigmentListNewUserAssigment)) { - AssigmentType oldAssigmentTypeOfUserAssigmentListNewUserAssigment = userAssigmentListNewUserAssigment.getAssigmentType(); - userAssigmentListNewUserAssigment.setAssigmentType(assigmentType); - userAssigmentListNewUserAssigment = em.merge(userAssigmentListNewUserAssigment); - if (oldAssigmentTypeOfUserAssigmentListNewUserAssigment != null && !oldAssigmentTypeOfUserAssigmentListNewUserAssigment.equals(assigmentType)) { - oldAssigmentTypeOfUserAssigmentListNewUserAssigment.getUserAssigmentList().remove(userAssigmentListNewUserAssigment); - oldAssigmentTypeOfUserAssigmentListNewUserAssigment = em.merge(oldAssigmentTypeOfUserAssigmentListNewUserAssigment); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = assigmentType.getId(); - if (findAssigmentType(id) == null) { - throw new NonexistentEntityException("The assigmentType with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - AssigmentType assigmentType; - try { - assigmentType = em.getReference(AssigmentType.class, id); - assigmentType.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The assigmentType with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List userAssigmentListOrphanCheck = assigmentType.getUserAssigmentList(); - for (UserAssigment userAssigmentListOrphanCheckUserAssigment : userAssigmentListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This AssigmentType (" + assigmentType + ") cannot be destroyed since the UserAssigment " + userAssigmentListOrphanCheckUserAssigment + " in its userAssigmentList field has a non-nullable assigmentType field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(assigmentType); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findAssigmentTypeEntities() { - return findAssigmentTypeEntities(true, -1, -1); - } - - public List findAssigmentTypeEntities(int maxResults, int firstResult) { - return findAssigmentTypeEntities(false, maxResults, firstResult); - } - - private List findAssigmentTypeEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(AssigmentType.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public AssigmentType findAssigmentType(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(AssigmentType.class, id); - } - finally { - em.close(); - } - } - - public int getAssigmentTypeCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(AssigmentType.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.AssigmentType; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.UserAssigment; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class AssigmentTypeJpaController implements Serializable { + + public AssigmentTypeJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(AssigmentType assigmentType) { + if (assigmentType.getUserAssigmentList() == null) { + assigmentType.setUserAssigmentList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedUserAssigmentList = new ArrayList<>(); + for (UserAssigment userAssigmentListUserAssigmentToAttach : assigmentType.getUserAssigmentList()) { + userAssigmentListUserAssigmentToAttach = em.getReference(userAssigmentListUserAssigmentToAttach.getClass(), userAssigmentListUserAssigmentToAttach.getUserAssigmentPK()); + attachedUserAssigmentList.add(userAssigmentListUserAssigmentToAttach); + } + assigmentType.setUserAssigmentList(attachedUserAssigmentList); + em.persist(assigmentType); + for (UserAssigment userAssigmentListUserAssigment : assigmentType.getUserAssigmentList()) { + AssigmentType oldAssigmentTypeOfUserAssigmentListUserAssigment = userAssigmentListUserAssigment.getAssigmentType(); + userAssigmentListUserAssigment.setAssigmentType(assigmentType); + userAssigmentListUserAssigment = em.merge(userAssigmentListUserAssigment); + if (oldAssigmentTypeOfUserAssigmentListUserAssigment != null) { + oldAssigmentTypeOfUserAssigmentListUserAssigment.getUserAssigmentList().remove(userAssigmentListUserAssigment); + oldAssigmentTypeOfUserAssigmentListUserAssigment = em.merge(oldAssigmentTypeOfUserAssigmentListUserAssigment); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(AssigmentType assigmentType) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + AssigmentType persistentAssigmentType = em.find(AssigmentType.class, assigmentType.getId()); + List userAssigmentListOld = persistentAssigmentType.getUserAssigmentList(); + List userAssigmentListNew = assigmentType.getUserAssigmentList(); + List illegalOrphanMessages = null; + for (UserAssigment userAssigmentListOldUserAssigment : userAssigmentListOld) { + if (!userAssigmentListNew.contains(userAssigmentListOldUserAssigment)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserAssigment " + userAssigmentListOldUserAssigment + " since its assigmentType field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedUserAssigmentListNew = new ArrayList<>(); + for (UserAssigment userAssigmentListNewUserAssigmentToAttach : userAssigmentListNew) { + userAssigmentListNewUserAssigmentToAttach = em.getReference(userAssigmentListNewUserAssigmentToAttach.getClass(), userAssigmentListNewUserAssigmentToAttach.getUserAssigmentPK()); + attachedUserAssigmentListNew.add(userAssigmentListNewUserAssigmentToAttach); + } + userAssigmentListNew = attachedUserAssigmentListNew; + assigmentType.setUserAssigmentList(userAssigmentListNew); + assigmentType = em.merge(assigmentType); + for (UserAssigment userAssigmentListNewUserAssigment : userAssigmentListNew) { + if (!userAssigmentListOld.contains(userAssigmentListNewUserAssigment)) { + AssigmentType oldAssigmentTypeOfUserAssigmentListNewUserAssigment = userAssigmentListNewUserAssigment.getAssigmentType(); + userAssigmentListNewUserAssigment.setAssigmentType(assigmentType); + userAssigmentListNewUserAssigment = em.merge(userAssigmentListNewUserAssigment); + if (oldAssigmentTypeOfUserAssigmentListNewUserAssigment != null && !oldAssigmentTypeOfUserAssigmentListNewUserAssigment.equals(assigmentType)) { + oldAssigmentTypeOfUserAssigmentListNewUserAssigment.getUserAssigmentList().remove(userAssigmentListNewUserAssigment); + oldAssigmentTypeOfUserAssigmentListNewUserAssigment = em.merge(oldAssigmentTypeOfUserAssigmentListNewUserAssigment); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = assigmentType.getId(); + if (findAssigmentType(id) == null) { + throw new NonexistentEntityException("The assigmentType with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + AssigmentType assigmentType; + try { + assigmentType = em.getReference(AssigmentType.class, id); + assigmentType.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The assigmentType with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List userAssigmentListOrphanCheck = assigmentType.getUserAssigmentList(); + for (UserAssigment userAssigmentListOrphanCheckUserAssigment : userAssigmentListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This AssigmentType (" + assigmentType + ") cannot be destroyed since the UserAssigment " + userAssigmentListOrphanCheckUserAssigment + " in its userAssigmentList field has a non-nullable assigmentType field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(assigmentType); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findAssigmentTypeEntities() { + return findAssigmentTypeEntities(true, -1, -1); + } + + public List findAssigmentTypeEntities(int maxResults, int firstResult) { + return findAssigmentTypeEntities(false, maxResults, firstResult); + } + + private List findAssigmentTypeEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(AssigmentType.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public AssigmentType findAssigmentType(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(AssigmentType.class, id); + } + finally { + em.close(); + } + } + + public int getAssigmentTypeCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(AssigmentType.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/AssignmentStatusJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/AssignmentStatusJpaController.java index 618ca14c..97769f3c 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/AssignmentStatusJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/AssignmentStatusJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.AssignmentStatus; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.UserAssigment; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class AssignmentStatusJpaController implements Serializable { - - public AssignmentStatusJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(AssignmentStatus assignmentStatus) { - if (assignmentStatus.getUserAssigmentList() == null) { - assignmentStatus.setUserAssigmentList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedUserAssigmentList = new ArrayList(); - for (UserAssigment userAssigmentListUserAssigmentToAttach : assignmentStatus.getUserAssigmentList()) { - userAssigmentListUserAssigmentToAttach = em.getReference(userAssigmentListUserAssigmentToAttach.getClass(), userAssigmentListUserAssigmentToAttach.getUserAssigmentPK()); - attachedUserAssigmentList.add(userAssigmentListUserAssigmentToAttach); - } - assignmentStatus.setUserAssigmentList(attachedUserAssigmentList); - em.persist(assignmentStatus); - for (UserAssigment userAssigmentListUserAssigment : assignmentStatus.getUserAssigmentList()) { - AssignmentStatus oldAssignmentStatusOfUserAssigmentListUserAssigment = userAssigmentListUserAssigment.getAssignmentStatus(); - userAssigmentListUserAssigment.setAssignmentStatus(assignmentStatus); - userAssigmentListUserAssigment = em.merge(userAssigmentListUserAssigment); - if (oldAssignmentStatusOfUserAssigmentListUserAssigment != null) { - oldAssignmentStatusOfUserAssigmentListUserAssigment.getUserAssigmentList().remove(userAssigmentListUserAssigment); - oldAssignmentStatusOfUserAssigmentListUserAssigment = em.merge(oldAssignmentStatusOfUserAssigmentListUserAssigment); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(AssignmentStatus assignmentStatus) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - AssignmentStatus persistentAssignmentStatus = em.find(AssignmentStatus.class, assignmentStatus.getId()); - List userAssigmentListOld = persistentAssignmentStatus.getUserAssigmentList(); - List userAssigmentListNew = assignmentStatus.getUserAssigmentList(); - List illegalOrphanMessages = null; - for (UserAssigment userAssigmentListOldUserAssigment : userAssigmentListOld) { - if (!userAssigmentListNew.contains(userAssigmentListOldUserAssigment)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserAssigment " + userAssigmentListOldUserAssigment + " since its assignmentStatus field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedUserAssigmentListNew = new ArrayList(); - for (UserAssigment userAssigmentListNewUserAssigmentToAttach : userAssigmentListNew) { - userAssigmentListNewUserAssigmentToAttach = em.getReference(userAssigmentListNewUserAssigmentToAttach.getClass(), userAssigmentListNewUserAssigmentToAttach.getUserAssigmentPK()); - attachedUserAssigmentListNew.add(userAssigmentListNewUserAssigmentToAttach); - } - userAssigmentListNew = attachedUserAssigmentListNew; - assignmentStatus.setUserAssigmentList(userAssigmentListNew); - assignmentStatus = em.merge(assignmentStatus); - for (UserAssigment userAssigmentListNewUserAssigment : userAssigmentListNew) { - if (!userAssigmentListOld.contains(userAssigmentListNewUserAssigment)) { - AssignmentStatus oldAssignmentStatusOfUserAssigmentListNewUserAssigment = userAssigmentListNewUserAssigment.getAssignmentStatus(); - userAssigmentListNewUserAssigment.setAssignmentStatus(assignmentStatus); - userAssigmentListNewUserAssigment = em.merge(userAssigmentListNewUserAssigment); - if (oldAssignmentStatusOfUserAssigmentListNewUserAssigment != null && !oldAssignmentStatusOfUserAssigmentListNewUserAssigment.equals(assignmentStatus)) { - oldAssignmentStatusOfUserAssigmentListNewUserAssigment.getUserAssigmentList().remove(userAssigmentListNewUserAssigment); - oldAssignmentStatusOfUserAssigmentListNewUserAssigment = em.merge(oldAssignmentStatusOfUserAssigmentListNewUserAssigment); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = assignmentStatus.getId(); - if (findAssignmentStatus(id) == null) { - throw new NonexistentEntityException("The assignmentStatus with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - AssignmentStatus assignmentStatus; - try { - assignmentStatus = em.getReference(AssignmentStatus.class, id); - assignmentStatus.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The assignmentStatus with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List userAssigmentListOrphanCheck = assignmentStatus.getUserAssigmentList(); - for (UserAssigment userAssigmentListOrphanCheckUserAssigment : userAssigmentListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This AssignmentStatus (" + assignmentStatus + ") cannot be destroyed since the UserAssigment " + userAssigmentListOrphanCheckUserAssigment + " in its userAssigmentList field has a non-nullable assignmentStatus field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(assignmentStatus); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findAssignmentStatusEntities() { - return findAssignmentStatusEntities(true, -1, -1); - } - - public List findAssignmentStatusEntities(int maxResults, int firstResult) { - return findAssignmentStatusEntities(false, maxResults, firstResult); - } - - private List findAssignmentStatusEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(AssignmentStatus.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public AssignmentStatus findAssignmentStatus(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(AssignmentStatus.class, id); - } - finally { - em.close(); - } - } - - public int getAssignmentStatusCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(AssignmentStatus.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.AssignmentStatus; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.UserAssigment; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class AssignmentStatusJpaController implements Serializable { + + public AssignmentStatusJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(AssignmentStatus assignmentStatus) { + if (assignmentStatus.getUserAssigmentList() == null) { + assignmentStatus.setUserAssigmentList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedUserAssigmentList = new ArrayList<>(); + for (UserAssigment userAssigmentListUserAssigmentToAttach : assignmentStatus.getUserAssigmentList()) { + userAssigmentListUserAssigmentToAttach = em.getReference(userAssigmentListUserAssigmentToAttach.getClass(), userAssigmentListUserAssigmentToAttach.getUserAssigmentPK()); + attachedUserAssigmentList.add(userAssigmentListUserAssigmentToAttach); + } + assignmentStatus.setUserAssigmentList(attachedUserAssigmentList); + em.persist(assignmentStatus); + for (UserAssigment userAssigmentListUserAssigment : assignmentStatus.getUserAssigmentList()) { + AssignmentStatus oldAssignmentStatusOfUserAssigmentListUserAssigment = userAssigmentListUserAssigment.getAssignmentStatus(); + userAssigmentListUserAssigment.setAssignmentStatus(assignmentStatus); + userAssigmentListUserAssigment = em.merge(userAssigmentListUserAssigment); + if (oldAssignmentStatusOfUserAssigmentListUserAssigment != null) { + oldAssignmentStatusOfUserAssigmentListUserAssigment.getUserAssigmentList().remove(userAssigmentListUserAssigment); + oldAssignmentStatusOfUserAssigmentListUserAssigment = em.merge(oldAssignmentStatusOfUserAssigmentListUserAssigment); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(AssignmentStatus assignmentStatus) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + AssignmentStatus persistentAssignmentStatus = em.find(AssignmentStatus.class, assignmentStatus.getId()); + List userAssigmentListOld = persistentAssignmentStatus.getUserAssigmentList(); + List userAssigmentListNew = assignmentStatus.getUserAssigmentList(); + List illegalOrphanMessages = null; + for (UserAssigment userAssigmentListOldUserAssigment : userAssigmentListOld) { + if (!userAssigmentListNew.contains(userAssigmentListOldUserAssigment)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserAssigment " + userAssigmentListOldUserAssigment + " since its assignmentStatus field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedUserAssigmentListNew = new ArrayList<>(); + for (UserAssigment userAssigmentListNewUserAssigmentToAttach : userAssigmentListNew) { + userAssigmentListNewUserAssigmentToAttach = em.getReference(userAssigmentListNewUserAssigmentToAttach.getClass(), userAssigmentListNewUserAssigmentToAttach.getUserAssigmentPK()); + attachedUserAssigmentListNew.add(userAssigmentListNewUserAssigmentToAttach); + } + userAssigmentListNew = attachedUserAssigmentListNew; + assignmentStatus.setUserAssigmentList(userAssigmentListNew); + assignmentStatus = em.merge(assignmentStatus); + for (UserAssigment userAssigmentListNewUserAssigment : userAssigmentListNew) { + if (!userAssigmentListOld.contains(userAssigmentListNewUserAssigment)) { + AssignmentStatus oldAssignmentStatusOfUserAssigmentListNewUserAssigment = userAssigmentListNewUserAssigment.getAssignmentStatus(); + userAssigmentListNewUserAssigment.setAssignmentStatus(assignmentStatus); + userAssigmentListNewUserAssigment = em.merge(userAssigmentListNewUserAssigment); + if (oldAssignmentStatusOfUserAssigmentListNewUserAssigment != null && !oldAssignmentStatusOfUserAssigmentListNewUserAssigment.equals(assignmentStatus)) { + oldAssignmentStatusOfUserAssigmentListNewUserAssigment.getUserAssigmentList().remove(userAssigmentListNewUserAssigment); + oldAssignmentStatusOfUserAssigmentListNewUserAssigment = em.merge(oldAssignmentStatusOfUserAssigmentListNewUserAssigment); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = assignmentStatus.getId(); + if (findAssignmentStatus(id) == null) { + throw new NonexistentEntityException("The assignmentStatus with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + AssignmentStatus assignmentStatus; + try { + assignmentStatus = em.getReference(AssignmentStatus.class, id); + assignmentStatus.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The assignmentStatus with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List userAssigmentListOrphanCheck = assignmentStatus.getUserAssigmentList(); + for (UserAssigment userAssigmentListOrphanCheckUserAssigment : userAssigmentListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This AssignmentStatus (" + assignmentStatus + ") cannot be destroyed since the UserAssigment " + userAssigmentListOrphanCheckUserAssigment + " in its userAssigmentList field has a non-nullable assignmentStatus field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(assignmentStatus); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findAssignmentStatusEntities() { + return findAssignmentStatusEntities(true, -1, -1); + } + + public List findAssignmentStatusEntities(int maxResults, int firstResult) { + return findAssignmentStatusEntities(false, maxResults, firstResult); + } + + private List findAssignmentStatusEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(AssignmentStatus.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public AssignmentStatus findAssignmentStatus(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(AssignmentStatus.class, id); + } + finally { + em.close(); + } + } + + public int getAssignmentStatusCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(AssignmentStatus.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/AttachmentJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/AttachmentJpaController.java index ff5bc8d6..db0b078a 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/AttachmentJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/AttachmentJpaController.java @@ -13,251 +13,251 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.Attachment; -import com.validation.manager.core.db.AttachmentPK; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.AttachmentType; -import com.validation.manager.core.db.ExecutionStepHasAttachment; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class AttachmentJpaController implements Serializable { - - public AttachmentJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(Attachment attachment) throws PreexistingEntityException, Exception { - if (attachment.getAttachmentPK() == null) { - attachment.setAttachmentPK(new AttachmentPK()); - } - if (attachment.getExecutionStepHasAttachmentList() == null) { - attachment.setExecutionStepHasAttachmentList(new ArrayList()); - } - attachment.getAttachmentPK().setAttachmentTypeId(attachment.getAttachmentType().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - AttachmentType attachmentType = attachment.getAttachmentType(); - if (attachmentType != null) { - attachmentType = em.getReference(attachmentType.getClass(), attachmentType.getId()); - attachment.setAttachmentType(attachmentType); - } - List attachedExecutionStepHasAttachmentList = new ArrayList(); - for (ExecutionStepHasAttachment executionStepHasAttachmentListExecutionStepHasAttachmentToAttach : attachment.getExecutionStepHasAttachmentList()) { - executionStepHasAttachmentListExecutionStepHasAttachmentToAttach = em.getReference(executionStepHasAttachmentListExecutionStepHasAttachmentToAttach.getClass(), executionStepHasAttachmentListExecutionStepHasAttachmentToAttach.getExecutionStepHasAttachmentPK()); - attachedExecutionStepHasAttachmentList.add(executionStepHasAttachmentListExecutionStepHasAttachmentToAttach); - } - attachment.setExecutionStepHasAttachmentList(attachedExecutionStepHasAttachmentList); - em.persist(attachment); - if (attachmentType != null) { - attachmentType.getAttachmentList().add(attachment); - attachmentType = em.merge(attachmentType); - } - for (ExecutionStepHasAttachment executionStepHasAttachmentListExecutionStepHasAttachment : attachment.getExecutionStepHasAttachmentList()) { - Attachment oldAttachmentOfExecutionStepHasAttachmentListExecutionStepHasAttachment = executionStepHasAttachmentListExecutionStepHasAttachment.getAttachment(); - executionStepHasAttachmentListExecutionStepHasAttachment.setAttachment(attachment); - executionStepHasAttachmentListExecutionStepHasAttachment = em.merge(executionStepHasAttachmentListExecutionStepHasAttachment); - if (oldAttachmentOfExecutionStepHasAttachmentListExecutionStepHasAttachment != null) { - oldAttachmentOfExecutionStepHasAttachmentListExecutionStepHasAttachment.getExecutionStepHasAttachmentList().remove(executionStepHasAttachmentListExecutionStepHasAttachment); - oldAttachmentOfExecutionStepHasAttachmentListExecutionStepHasAttachment = em.merge(oldAttachmentOfExecutionStepHasAttachmentListExecutionStepHasAttachment); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findAttachment(attachment.getAttachmentPK()) != null) { - throw new PreexistingEntityException("Attachment " + attachment + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(Attachment attachment) throws IllegalOrphanException, NonexistentEntityException, Exception { - attachment.getAttachmentPK().setAttachmentTypeId(attachment.getAttachmentType().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Attachment persistentAttachment = em.find(Attachment.class, attachment.getAttachmentPK()); - AttachmentType attachmentTypeOld = persistentAttachment.getAttachmentType(); - AttachmentType attachmentTypeNew = attachment.getAttachmentType(); - List executionStepHasAttachmentListOld = persistentAttachment.getExecutionStepHasAttachmentList(); - List executionStepHasAttachmentListNew = attachment.getExecutionStepHasAttachmentList(); - List illegalOrphanMessages = null; - for (ExecutionStepHasAttachment executionStepHasAttachmentListOldExecutionStepHasAttachment : executionStepHasAttachmentListOld) { - if (!executionStepHasAttachmentListNew.contains(executionStepHasAttachmentListOldExecutionStepHasAttachment)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExecutionStepHasAttachment " + executionStepHasAttachmentListOldExecutionStepHasAttachment + " since its attachment field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (attachmentTypeNew != null) { - attachmentTypeNew = em.getReference(attachmentTypeNew.getClass(), attachmentTypeNew.getId()); - attachment.setAttachmentType(attachmentTypeNew); - } - List attachedExecutionStepHasAttachmentListNew = new ArrayList(); - for (ExecutionStepHasAttachment executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach : executionStepHasAttachmentListNew) { - executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach = em.getReference(executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach.getClass(), executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach.getExecutionStepHasAttachmentPK()); - attachedExecutionStepHasAttachmentListNew.add(executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach); - } - executionStepHasAttachmentListNew = attachedExecutionStepHasAttachmentListNew; - attachment.setExecutionStepHasAttachmentList(executionStepHasAttachmentListNew); - attachment = em.merge(attachment); - if (attachmentTypeOld != null && !attachmentTypeOld.equals(attachmentTypeNew)) { - attachmentTypeOld.getAttachmentList().remove(attachment); - attachmentTypeOld = em.merge(attachmentTypeOld); - } - if (attachmentTypeNew != null && !attachmentTypeNew.equals(attachmentTypeOld)) { - attachmentTypeNew.getAttachmentList().add(attachment); - attachmentTypeNew = em.merge(attachmentTypeNew); - } - for (ExecutionStepHasAttachment executionStepHasAttachmentListNewExecutionStepHasAttachment : executionStepHasAttachmentListNew) { - if (!executionStepHasAttachmentListOld.contains(executionStepHasAttachmentListNewExecutionStepHasAttachment)) { - Attachment oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment = executionStepHasAttachmentListNewExecutionStepHasAttachment.getAttachment(); - executionStepHasAttachmentListNewExecutionStepHasAttachment.setAttachment(attachment); - executionStepHasAttachmentListNewExecutionStepHasAttachment = em.merge(executionStepHasAttachmentListNewExecutionStepHasAttachment); - if (oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment != null && !oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment.equals(attachment)) { - oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment.getExecutionStepHasAttachmentList().remove(executionStepHasAttachmentListNewExecutionStepHasAttachment); - oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment = em.merge(oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - AttachmentPK id = attachment.getAttachmentPK(); - if (findAttachment(id) == null) { - throw new NonexistentEntityException("The attachment with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(AttachmentPK id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Attachment attachment; - try { - attachment = em.getReference(Attachment.class, id); - attachment.getAttachmentPK(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The attachment with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List executionStepHasAttachmentListOrphanCheck = attachment.getExecutionStepHasAttachmentList(); - for (ExecutionStepHasAttachment executionStepHasAttachmentListOrphanCheckExecutionStepHasAttachment : executionStepHasAttachmentListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Attachment (" + attachment + ") cannot be destroyed since the ExecutionStepHasAttachment " + executionStepHasAttachmentListOrphanCheckExecutionStepHasAttachment + " in its executionStepHasAttachmentList field has a non-nullable attachment field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - AttachmentType attachmentType = attachment.getAttachmentType(); - if (attachmentType != null) { - attachmentType.getAttachmentList().remove(attachment); - attachmentType = em.merge(attachmentType); - } - em.remove(attachment); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findAttachmentEntities() { - return findAttachmentEntities(true, -1, -1); - } - - public List findAttachmentEntities(int maxResults, int firstResult) { - return findAttachmentEntities(false, maxResults, firstResult); - } - - private List findAttachmentEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(Attachment.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public Attachment findAttachment(AttachmentPK id) { - EntityManager em = getEntityManager(); - try { - return em.find(Attachment.class, id); - } - finally { - em.close(); - } - } - - public int getAttachmentCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(Attachment.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.Attachment; +import com.validation.manager.core.db.AttachmentPK; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.AttachmentType; +import com.validation.manager.core.db.ExecutionStepHasAttachment; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class AttachmentJpaController implements Serializable { + + public AttachmentJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(Attachment attachment) throws PreexistingEntityException, Exception { + if (attachment.getAttachmentPK() == null) { + attachment.setAttachmentPK(new AttachmentPK()); + } + if (attachment.getExecutionStepHasAttachmentList() == null) { + attachment.setExecutionStepHasAttachmentList(new ArrayList<>()); + } + attachment.getAttachmentPK().setAttachmentTypeId(attachment.getAttachmentType().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + AttachmentType attachmentType = attachment.getAttachmentType(); + if (attachmentType != null) { + attachmentType = em.getReference(attachmentType.getClass(), attachmentType.getId()); + attachment.setAttachmentType(attachmentType); + } + List attachedExecutionStepHasAttachmentList = new ArrayList<>(); + for (ExecutionStepHasAttachment executionStepHasAttachmentListExecutionStepHasAttachmentToAttach : attachment.getExecutionStepHasAttachmentList()) { + executionStepHasAttachmentListExecutionStepHasAttachmentToAttach = em.getReference(executionStepHasAttachmentListExecutionStepHasAttachmentToAttach.getClass(), executionStepHasAttachmentListExecutionStepHasAttachmentToAttach.getExecutionStepHasAttachmentPK()); + attachedExecutionStepHasAttachmentList.add(executionStepHasAttachmentListExecutionStepHasAttachmentToAttach); + } + attachment.setExecutionStepHasAttachmentList(attachedExecutionStepHasAttachmentList); + em.persist(attachment); + if (attachmentType != null) { + attachmentType.getAttachmentList().add(attachment); + attachmentType = em.merge(attachmentType); + } + for (ExecutionStepHasAttachment executionStepHasAttachmentListExecutionStepHasAttachment : attachment.getExecutionStepHasAttachmentList()) { + Attachment oldAttachmentOfExecutionStepHasAttachmentListExecutionStepHasAttachment = executionStepHasAttachmentListExecutionStepHasAttachment.getAttachment(); + executionStepHasAttachmentListExecutionStepHasAttachment.setAttachment(attachment); + executionStepHasAttachmentListExecutionStepHasAttachment = em.merge(executionStepHasAttachmentListExecutionStepHasAttachment); + if (oldAttachmentOfExecutionStepHasAttachmentListExecutionStepHasAttachment != null) { + oldAttachmentOfExecutionStepHasAttachmentListExecutionStepHasAttachment.getExecutionStepHasAttachmentList().remove(executionStepHasAttachmentListExecutionStepHasAttachment); + oldAttachmentOfExecutionStepHasAttachmentListExecutionStepHasAttachment = em.merge(oldAttachmentOfExecutionStepHasAttachmentListExecutionStepHasAttachment); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findAttachment(attachment.getAttachmentPK()) != null) { + throw new PreexistingEntityException("Attachment " + attachment + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(Attachment attachment) throws IllegalOrphanException, NonexistentEntityException, Exception { + attachment.getAttachmentPK().setAttachmentTypeId(attachment.getAttachmentType().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Attachment persistentAttachment = em.find(Attachment.class, attachment.getAttachmentPK()); + AttachmentType attachmentTypeOld = persistentAttachment.getAttachmentType(); + AttachmentType attachmentTypeNew = attachment.getAttachmentType(); + List executionStepHasAttachmentListOld = persistentAttachment.getExecutionStepHasAttachmentList(); + List executionStepHasAttachmentListNew = attachment.getExecutionStepHasAttachmentList(); + List illegalOrphanMessages = null; + for (ExecutionStepHasAttachment executionStepHasAttachmentListOldExecutionStepHasAttachment : executionStepHasAttachmentListOld) { + if (!executionStepHasAttachmentListNew.contains(executionStepHasAttachmentListOldExecutionStepHasAttachment)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExecutionStepHasAttachment " + executionStepHasAttachmentListOldExecutionStepHasAttachment + " since its attachment field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (attachmentTypeNew != null) { + attachmentTypeNew = em.getReference(attachmentTypeNew.getClass(), attachmentTypeNew.getId()); + attachment.setAttachmentType(attachmentTypeNew); + } + List attachedExecutionStepHasAttachmentListNew = new ArrayList<>(); + for (ExecutionStepHasAttachment executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach : executionStepHasAttachmentListNew) { + executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach = em.getReference(executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach.getClass(), executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach.getExecutionStepHasAttachmentPK()); + attachedExecutionStepHasAttachmentListNew.add(executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach); + } + executionStepHasAttachmentListNew = attachedExecutionStepHasAttachmentListNew; + attachment.setExecutionStepHasAttachmentList(executionStepHasAttachmentListNew); + attachment = em.merge(attachment); + if (attachmentTypeOld != null && !attachmentTypeOld.equals(attachmentTypeNew)) { + attachmentTypeOld.getAttachmentList().remove(attachment); + attachmentTypeOld = em.merge(attachmentTypeOld); + } + if (attachmentTypeNew != null && !attachmentTypeNew.equals(attachmentTypeOld)) { + attachmentTypeNew.getAttachmentList().add(attachment); + attachmentTypeNew = em.merge(attachmentTypeNew); + } + for (ExecutionStepHasAttachment executionStepHasAttachmentListNewExecutionStepHasAttachment : executionStepHasAttachmentListNew) { + if (!executionStepHasAttachmentListOld.contains(executionStepHasAttachmentListNewExecutionStepHasAttachment)) { + Attachment oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment = executionStepHasAttachmentListNewExecutionStepHasAttachment.getAttachment(); + executionStepHasAttachmentListNewExecutionStepHasAttachment.setAttachment(attachment); + executionStepHasAttachmentListNewExecutionStepHasAttachment = em.merge(executionStepHasAttachmentListNewExecutionStepHasAttachment); + if (oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment != null && !oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment.equals(attachment)) { + oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment.getExecutionStepHasAttachmentList().remove(executionStepHasAttachmentListNewExecutionStepHasAttachment); + oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment = em.merge(oldAttachmentOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + AttachmentPK id = attachment.getAttachmentPK(); + if (findAttachment(id) == null) { + throw new NonexistentEntityException("The attachment with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(AttachmentPK id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Attachment attachment; + try { + attachment = em.getReference(Attachment.class, id); + attachment.getAttachmentPK(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The attachment with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List executionStepHasAttachmentListOrphanCheck = attachment.getExecutionStepHasAttachmentList(); + for (ExecutionStepHasAttachment executionStepHasAttachmentListOrphanCheckExecutionStepHasAttachment : executionStepHasAttachmentListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Attachment (" + attachment + ") cannot be destroyed since the ExecutionStepHasAttachment " + executionStepHasAttachmentListOrphanCheckExecutionStepHasAttachment + " in its executionStepHasAttachmentList field has a non-nullable attachment field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + AttachmentType attachmentType = attachment.getAttachmentType(); + if (attachmentType != null) { + attachmentType.getAttachmentList().remove(attachment); + attachmentType = em.merge(attachmentType); + } + em.remove(attachment); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findAttachmentEntities() { + return findAttachmentEntities(true, -1, -1); + } + + public List findAttachmentEntities(int maxResults, int firstResult) { + return findAttachmentEntities(false, maxResults, firstResult); + } + + private List findAttachmentEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(Attachment.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public Attachment findAttachment(AttachmentPK id) { + EntityManager em = getEntityManager(); + try { + return em.find(Attachment.class, id); + } + finally { + em.close(); + } + } + + public int getAttachmentCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(Attachment.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/AttachmentTypeJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/AttachmentTypeJpaController.java index dc21299b..bed6c230 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/AttachmentTypeJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/AttachmentTypeJpaController.java @@ -13,216 +13,216 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Attachment; -import com.validation.manager.core.db.AttachmentType; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class AttachmentTypeJpaController implements Serializable { - - public AttachmentTypeJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(AttachmentType attachmentType) throws PreexistingEntityException, Exception { - if (attachmentType.getAttachmentList() == null) { - attachmentType.setAttachmentList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedAttachmentList = new ArrayList(); - for (Attachment attachmentListAttachmentToAttach : attachmentType.getAttachmentList()) { - attachmentListAttachmentToAttach = em.getReference(attachmentListAttachmentToAttach.getClass(), attachmentListAttachmentToAttach.getAttachmentPK()); - attachedAttachmentList.add(attachmentListAttachmentToAttach); - } - attachmentType.setAttachmentList(attachedAttachmentList); - em.persist(attachmentType); - for (Attachment attachmentListAttachment : attachmentType.getAttachmentList()) { - AttachmentType oldAttachmentTypeOfAttachmentListAttachment = attachmentListAttachment.getAttachmentType(); - attachmentListAttachment.setAttachmentType(attachmentType); - attachmentListAttachment = em.merge(attachmentListAttachment); - if (oldAttachmentTypeOfAttachmentListAttachment != null) { - oldAttachmentTypeOfAttachmentListAttachment.getAttachmentList().remove(attachmentListAttachment); - oldAttachmentTypeOfAttachmentListAttachment = em.merge(oldAttachmentTypeOfAttachmentListAttachment); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findAttachmentType(attachmentType.getId()) != null) { - throw new PreexistingEntityException("AttachmentType " + attachmentType + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(AttachmentType attachmentType) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - AttachmentType persistentAttachmentType = em.find(AttachmentType.class, attachmentType.getId()); - List attachmentListOld = persistentAttachmentType.getAttachmentList(); - List attachmentListNew = attachmentType.getAttachmentList(); - List illegalOrphanMessages = null; - for (Attachment attachmentListOldAttachment : attachmentListOld) { - if (!attachmentListNew.contains(attachmentListOldAttachment)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain Attachment " + attachmentListOldAttachment + " since its attachmentType field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedAttachmentListNew = new ArrayList(); - for (Attachment attachmentListNewAttachmentToAttach : attachmentListNew) { - attachmentListNewAttachmentToAttach = em.getReference(attachmentListNewAttachmentToAttach.getClass(), attachmentListNewAttachmentToAttach.getAttachmentPK()); - attachedAttachmentListNew.add(attachmentListNewAttachmentToAttach); - } - attachmentListNew = attachedAttachmentListNew; - attachmentType.setAttachmentList(attachmentListNew); - attachmentType = em.merge(attachmentType); - for (Attachment attachmentListNewAttachment : attachmentListNew) { - if (!attachmentListOld.contains(attachmentListNewAttachment)) { - AttachmentType oldAttachmentTypeOfAttachmentListNewAttachment = attachmentListNewAttachment.getAttachmentType(); - attachmentListNewAttachment.setAttachmentType(attachmentType); - attachmentListNewAttachment = em.merge(attachmentListNewAttachment); - if (oldAttachmentTypeOfAttachmentListNewAttachment != null && !oldAttachmentTypeOfAttachmentListNewAttachment.equals(attachmentType)) { - oldAttachmentTypeOfAttachmentListNewAttachment.getAttachmentList().remove(attachmentListNewAttachment); - oldAttachmentTypeOfAttachmentListNewAttachment = em.merge(oldAttachmentTypeOfAttachmentListNewAttachment); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = attachmentType.getId(); - if (findAttachmentType(id) == null) { - throw new NonexistentEntityException("The attachmentType with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - AttachmentType attachmentType; - try { - attachmentType = em.getReference(AttachmentType.class, id); - attachmentType.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The attachmentType with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List attachmentListOrphanCheck = attachmentType.getAttachmentList(); - for (Attachment attachmentListOrphanCheckAttachment : attachmentListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This AttachmentType (" + attachmentType + ") cannot be destroyed since the Attachment " + attachmentListOrphanCheckAttachment + " in its attachmentList field has a non-nullable attachmentType field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(attachmentType); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findAttachmentTypeEntities() { - return findAttachmentTypeEntities(true, -1, -1); - } - - public List findAttachmentTypeEntities(int maxResults, int firstResult) { - return findAttachmentTypeEntities(false, maxResults, firstResult); - } - - private List findAttachmentTypeEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(AttachmentType.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public AttachmentType findAttachmentType(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(AttachmentType.class, id); - } - finally { - em.close(); - } - } - - public int getAttachmentTypeCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(AttachmentType.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Attachment; +import com.validation.manager.core.db.AttachmentType; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class AttachmentTypeJpaController implements Serializable { + + public AttachmentTypeJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(AttachmentType attachmentType) throws PreexistingEntityException, Exception { + if (attachmentType.getAttachmentList() == null) { + attachmentType.setAttachmentList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedAttachmentList = new ArrayList<>(); + for (Attachment attachmentListAttachmentToAttach : attachmentType.getAttachmentList()) { + attachmentListAttachmentToAttach = em.getReference(attachmentListAttachmentToAttach.getClass(), attachmentListAttachmentToAttach.getAttachmentPK()); + attachedAttachmentList.add(attachmentListAttachmentToAttach); + } + attachmentType.setAttachmentList(attachedAttachmentList); + em.persist(attachmentType); + for (Attachment attachmentListAttachment : attachmentType.getAttachmentList()) { + AttachmentType oldAttachmentTypeOfAttachmentListAttachment = attachmentListAttachment.getAttachmentType(); + attachmentListAttachment.setAttachmentType(attachmentType); + attachmentListAttachment = em.merge(attachmentListAttachment); + if (oldAttachmentTypeOfAttachmentListAttachment != null) { + oldAttachmentTypeOfAttachmentListAttachment.getAttachmentList().remove(attachmentListAttachment); + oldAttachmentTypeOfAttachmentListAttachment = em.merge(oldAttachmentTypeOfAttachmentListAttachment); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findAttachmentType(attachmentType.getId()) != null) { + throw new PreexistingEntityException("AttachmentType " + attachmentType + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(AttachmentType attachmentType) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + AttachmentType persistentAttachmentType = em.find(AttachmentType.class, attachmentType.getId()); + List attachmentListOld = persistentAttachmentType.getAttachmentList(); + List attachmentListNew = attachmentType.getAttachmentList(); + List illegalOrphanMessages = null; + for (Attachment attachmentListOldAttachment : attachmentListOld) { + if (!attachmentListNew.contains(attachmentListOldAttachment)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain Attachment " + attachmentListOldAttachment + " since its attachmentType field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedAttachmentListNew = new ArrayList<>(); + for (Attachment attachmentListNewAttachmentToAttach : attachmentListNew) { + attachmentListNewAttachmentToAttach = em.getReference(attachmentListNewAttachmentToAttach.getClass(), attachmentListNewAttachmentToAttach.getAttachmentPK()); + attachedAttachmentListNew.add(attachmentListNewAttachmentToAttach); + } + attachmentListNew = attachedAttachmentListNew; + attachmentType.setAttachmentList(attachmentListNew); + attachmentType = em.merge(attachmentType); + for (Attachment attachmentListNewAttachment : attachmentListNew) { + if (!attachmentListOld.contains(attachmentListNewAttachment)) { + AttachmentType oldAttachmentTypeOfAttachmentListNewAttachment = attachmentListNewAttachment.getAttachmentType(); + attachmentListNewAttachment.setAttachmentType(attachmentType); + attachmentListNewAttachment = em.merge(attachmentListNewAttachment); + if (oldAttachmentTypeOfAttachmentListNewAttachment != null && !oldAttachmentTypeOfAttachmentListNewAttachment.equals(attachmentType)) { + oldAttachmentTypeOfAttachmentListNewAttachment.getAttachmentList().remove(attachmentListNewAttachment); + oldAttachmentTypeOfAttachmentListNewAttachment = em.merge(oldAttachmentTypeOfAttachmentListNewAttachment); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = attachmentType.getId(); + if (findAttachmentType(id) == null) { + throw new NonexistentEntityException("The attachmentType with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + AttachmentType attachmentType; + try { + attachmentType = em.getReference(AttachmentType.class, id); + attachmentType.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The attachmentType with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List attachmentListOrphanCheck = attachmentType.getAttachmentList(); + for (Attachment attachmentListOrphanCheckAttachment : attachmentListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This AttachmentType (" + attachmentType + ") cannot be destroyed since the Attachment " + attachmentListOrphanCheckAttachment + " in its attachmentList field has a non-nullable attachmentType field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(attachmentType); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findAttachmentTypeEntities() { + return findAttachmentTypeEntities(true, -1, -1); + } + + public List findAttachmentTypeEntities(int maxResults, int firstResult) { + return findAttachmentTypeEntities(false, maxResults, firstResult); + } + + private List findAttachmentTypeEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(AttachmentType.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public AttachmentType findAttachmentType(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(AttachmentType.class, id); + } + finally { + em.close(); + } + } + + public int getAttachmentTypeCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(AttachmentType.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/BaselineJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/BaselineJpaController.java index b0be06f0..00adada8 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/BaselineJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/BaselineJpaController.java @@ -13,215 +13,215 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.Baseline; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.RequirementSpec; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class BaselineJpaController implements Serializable { - - public BaselineJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(Baseline baseline) { - if (baseline.getHistoryList() == null) { - baseline.setHistoryList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RequirementSpec requirementSpec = baseline.getRequirementSpec(); - if (requirementSpec != null) { - requirementSpec = em.getReference(requirementSpec.getClass(), requirementSpec.getRequirementSpecPK()); - baseline.setRequirementSpec(requirementSpec); - } - List attachedHistoryList = new ArrayList(); - for (History historyListHistoryToAttach : baseline.getHistoryList()) { - historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); - attachedHistoryList.add(historyListHistoryToAttach); - } - baseline.setHistoryList(attachedHistoryList); - em.persist(baseline); - if (requirementSpec != null) { - requirementSpec.getBaselineList().add(baseline); - requirementSpec = em.merge(requirementSpec); - } - for (History historyListHistory : baseline.getHistoryList()) { - historyListHistory.getBaselineList().add(baseline); - historyListHistory = em.merge(historyListHistory); - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(Baseline baseline) throws NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Baseline persistentBaseline = em.find(Baseline.class, baseline.getId()); - RequirementSpec requirementSpecOld = persistentBaseline.getRequirementSpec(); - RequirementSpec requirementSpecNew = baseline.getRequirementSpec(); - List historyListOld = persistentBaseline.getHistoryList(); - List historyListNew = baseline.getHistoryList(); - if (requirementSpecNew != null) { - requirementSpecNew = em.getReference(requirementSpecNew.getClass(), requirementSpecNew.getRequirementSpecPK()); - baseline.setRequirementSpec(requirementSpecNew); - } - List attachedHistoryListNew = new ArrayList(); - for (History historyListNewHistoryToAttach : historyListNew) { - historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); - attachedHistoryListNew.add(historyListNewHistoryToAttach); - } - historyListNew = attachedHistoryListNew; - baseline.setHistoryList(historyListNew); - baseline = em.merge(baseline); - if (requirementSpecOld != null && !requirementSpecOld.equals(requirementSpecNew)) { - requirementSpecOld.getBaselineList().remove(baseline); - requirementSpecOld = em.merge(requirementSpecOld); - } - if (requirementSpecNew != null && !requirementSpecNew.equals(requirementSpecOld)) { - requirementSpecNew.getBaselineList().add(baseline); - requirementSpecNew = em.merge(requirementSpecNew); - } - for (History historyListOldHistory : historyListOld) { - if (!historyListNew.contains(historyListOldHistory)) { - historyListOldHistory.getBaselineList().remove(baseline); - historyListOldHistory = em.merge(historyListOldHistory); - } - } - for (History historyListNewHistory : historyListNew) { - if (!historyListOld.contains(historyListNewHistory)) { - historyListNewHistory.getBaselineList().add(baseline); - historyListNewHistory = em.merge(historyListNewHistory); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = baseline.getId(); - if (findBaseline(id) == null) { - throw new NonexistentEntityException("The baseline with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Baseline baseline; - try { - baseline = em.getReference(Baseline.class, id); - baseline.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The baseline with id " + id + " no longer exists.", enfe); - } - RequirementSpec requirementSpec = baseline.getRequirementSpec(); - if (requirementSpec != null) { - requirementSpec.getBaselineList().remove(baseline); - requirementSpec = em.merge(requirementSpec); - } - List historyList = baseline.getHistoryList(); - for (History historyListHistory : historyList) { - historyListHistory.getBaselineList().remove(baseline); - historyListHistory = em.merge(historyListHistory); - } - em.remove(baseline); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findBaselineEntities() { - return findBaselineEntities(true, -1, -1); - } - - public List findBaselineEntities(int maxResults, int firstResult) { - return findBaselineEntities(false, maxResults, firstResult); - } - - private List findBaselineEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(Baseline.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public Baseline findBaseline(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(Baseline.class, id); - } - finally { - em.close(); - } - } - - public int getBaselineCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(Baseline.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.Baseline; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.RequirementSpec; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class BaselineJpaController implements Serializable { + + public BaselineJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(Baseline baseline) { + if (baseline.getHistoryList() == null) { + baseline.setHistoryList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RequirementSpec requirementSpec = baseline.getRequirementSpec(); + if (requirementSpec != null) { + requirementSpec = em.getReference(requirementSpec.getClass(), requirementSpec.getRequirementSpecPK()); + baseline.setRequirementSpec(requirementSpec); + } + List attachedHistoryList = new ArrayList<>(); + for (History historyListHistoryToAttach : baseline.getHistoryList()) { + historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); + attachedHistoryList.add(historyListHistoryToAttach); + } + baseline.setHistoryList(attachedHistoryList); + em.persist(baseline); + if (requirementSpec != null) { + requirementSpec.getBaselineList().add(baseline); + requirementSpec = em.merge(requirementSpec); + } + for (History historyListHistory : baseline.getHistoryList()) { + historyListHistory.getBaselineList().add(baseline); + historyListHistory = em.merge(historyListHistory); + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(Baseline baseline) throws NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Baseline persistentBaseline = em.find(Baseline.class, baseline.getId()); + RequirementSpec requirementSpecOld = persistentBaseline.getRequirementSpec(); + RequirementSpec requirementSpecNew = baseline.getRequirementSpec(); + List historyListOld = persistentBaseline.getHistoryList(); + List historyListNew = baseline.getHistoryList(); + if (requirementSpecNew != null) { + requirementSpecNew = em.getReference(requirementSpecNew.getClass(), requirementSpecNew.getRequirementSpecPK()); + baseline.setRequirementSpec(requirementSpecNew); + } + List attachedHistoryListNew = new ArrayList<>(); + for (History historyListNewHistoryToAttach : historyListNew) { + historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); + attachedHistoryListNew.add(historyListNewHistoryToAttach); + } + historyListNew = attachedHistoryListNew; + baseline.setHistoryList(historyListNew); + baseline = em.merge(baseline); + if (requirementSpecOld != null && !requirementSpecOld.equals(requirementSpecNew)) { + requirementSpecOld.getBaselineList().remove(baseline); + requirementSpecOld = em.merge(requirementSpecOld); + } + if (requirementSpecNew != null && !requirementSpecNew.equals(requirementSpecOld)) { + requirementSpecNew.getBaselineList().add(baseline); + requirementSpecNew = em.merge(requirementSpecNew); + } + for (History historyListOldHistory : historyListOld) { + if (!historyListNew.contains(historyListOldHistory)) { + historyListOldHistory.getBaselineList().remove(baseline); + historyListOldHistory = em.merge(historyListOldHistory); + } + } + for (History historyListNewHistory : historyListNew) { + if (!historyListOld.contains(historyListNewHistory)) { + historyListNewHistory.getBaselineList().add(baseline); + historyListNewHistory = em.merge(historyListNewHistory); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = baseline.getId(); + if (findBaseline(id) == null) { + throw new NonexistentEntityException("The baseline with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Baseline baseline; + try { + baseline = em.getReference(Baseline.class, id); + baseline.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The baseline with id " + id + " no longer exists.", enfe); + } + RequirementSpec requirementSpec = baseline.getRequirementSpec(); + if (requirementSpec != null) { + requirementSpec.getBaselineList().remove(baseline); + requirementSpec = em.merge(requirementSpec); + } + List historyList = baseline.getHistoryList(); + for (History historyListHistory : historyList) { + historyListHistory.getBaselineList().remove(baseline); + historyListHistory = em.merge(historyListHistory); + } + em.remove(baseline); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findBaselineEntities() { + return findBaselineEntities(true, -1, -1); + } + + public List findBaselineEntities(int maxResults, int firstResult) { + return findBaselineEntities(false, maxResults, firstResult); + } + + private List findBaselineEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(Baseline.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public Baseline findBaseline(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(Baseline.class, id); + } + finally { + em.close(); + } + } + + public int getBaselineCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(Baseline.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/CauseJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/CauseJpaController.java index 1ed661c0..fd88059d 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/CauseJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/CauseJpaController.java @@ -13,186 +13,186 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.Cause; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.RiskItem; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class CauseJpaController implements Serializable { - - public CauseJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(Cause cause) { - if (cause.getRiskItemList() == null) { - cause.setRiskItemList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedRiskItemList = new ArrayList(); - for (RiskItem riskItemListRiskItemToAttach : cause.getRiskItemList()) { - riskItemListRiskItemToAttach = em.getReference(riskItemListRiskItemToAttach.getClass(), riskItemListRiskItemToAttach.getRiskItemPK()); - attachedRiskItemList.add(riskItemListRiskItemToAttach); - } - cause.setRiskItemList(attachedRiskItemList); - em.persist(cause); - for (RiskItem riskItemListRiskItem : cause.getRiskItemList()) { - riskItemListRiskItem.getCauseList().add(cause); - riskItemListRiskItem = em.merge(riskItemListRiskItem); - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(Cause cause) throws NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Cause persistentCause = em.find(Cause.class, cause.getId()); - List riskItemListOld = persistentCause.getRiskItemList(); - List riskItemListNew = cause.getRiskItemList(); - List attachedRiskItemListNew = new ArrayList(); - for (RiskItem riskItemListNewRiskItemToAttach : riskItemListNew) { - riskItemListNewRiskItemToAttach = em.getReference(riskItemListNewRiskItemToAttach.getClass(), riskItemListNewRiskItemToAttach.getRiskItemPK()); - attachedRiskItemListNew.add(riskItemListNewRiskItemToAttach); - } - riskItemListNew = attachedRiskItemListNew; - cause.setRiskItemList(riskItemListNew); - cause = em.merge(cause); - for (RiskItem riskItemListOldRiskItem : riskItemListOld) { - if (!riskItemListNew.contains(riskItemListOldRiskItem)) { - riskItemListOldRiskItem.getCauseList().remove(cause); - riskItemListOldRiskItem = em.merge(riskItemListOldRiskItem); - } - } - for (RiskItem riskItemListNewRiskItem : riskItemListNew) { - if (!riskItemListOld.contains(riskItemListNewRiskItem)) { - riskItemListNewRiskItem.getCauseList().add(cause); - riskItemListNewRiskItem = em.merge(riskItemListNewRiskItem); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = cause.getId(); - if (findCause(id) == null) { - throw new NonexistentEntityException("The cause with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Cause cause; - try { - cause = em.getReference(Cause.class, id); - cause.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The cause with id " + id + " no longer exists.", enfe); - } - List riskItemList = cause.getRiskItemList(); - for (RiskItem riskItemListRiskItem : riskItemList) { - riskItemListRiskItem.getCauseList().remove(cause); - riskItemListRiskItem = em.merge(riskItemListRiskItem); - } - em.remove(cause); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findCauseEntities() { - return findCauseEntities(true, -1, -1); - } - - public List findCauseEntities(int maxResults, int firstResult) { - return findCauseEntities(false, maxResults, firstResult); - } - - private List findCauseEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(Cause.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public Cause findCause(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(Cause.class, id); - } - finally { - em.close(); - } - } - - public int getCauseCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(Cause.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.Cause; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.RiskItem; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class CauseJpaController implements Serializable { + + public CauseJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(Cause cause) { + if (cause.getRiskItemList() == null) { + cause.setRiskItemList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedRiskItemList = new ArrayList<>(); + for (RiskItem riskItemListRiskItemToAttach : cause.getRiskItemList()) { + riskItemListRiskItemToAttach = em.getReference(riskItemListRiskItemToAttach.getClass(), riskItemListRiskItemToAttach.getRiskItemPK()); + attachedRiskItemList.add(riskItemListRiskItemToAttach); + } + cause.setRiskItemList(attachedRiskItemList); + em.persist(cause); + for (RiskItem riskItemListRiskItem : cause.getRiskItemList()) { + riskItemListRiskItem.getCauseList().add(cause); + riskItemListRiskItem = em.merge(riskItemListRiskItem); + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(Cause cause) throws NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Cause persistentCause = em.find(Cause.class, cause.getId()); + List riskItemListOld = persistentCause.getRiskItemList(); + List riskItemListNew = cause.getRiskItemList(); + List attachedRiskItemListNew = new ArrayList<>(); + for (RiskItem riskItemListNewRiskItemToAttach : riskItemListNew) { + riskItemListNewRiskItemToAttach = em.getReference(riskItemListNewRiskItemToAttach.getClass(), riskItemListNewRiskItemToAttach.getRiskItemPK()); + attachedRiskItemListNew.add(riskItemListNewRiskItemToAttach); + } + riskItemListNew = attachedRiskItemListNew; + cause.setRiskItemList(riskItemListNew); + cause = em.merge(cause); + for (RiskItem riskItemListOldRiskItem : riskItemListOld) { + if (!riskItemListNew.contains(riskItemListOldRiskItem)) { + riskItemListOldRiskItem.getCauseList().remove(cause); + riskItemListOldRiskItem = em.merge(riskItemListOldRiskItem); + } + } + for (RiskItem riskItemListNewRiskItem : riskItemListNew) { + if (!riskItemListOld.contains(riskItemListNewRiskItem)) { + riskItemListNewRiskItem.getCauseList().add(cause); + riskItemListNewRiskItem = em.merge(riskItemListNewRiskItem); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = cause.getId(); + if (findCause(id) == null) { + throw new NonexistentEntityException("The cause with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Cause cause; + try { + cause = em.getReference(Cause.class, id); + cause.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The cause with id " + id + " no longer exists.", enfe); + } + List riskItemList = cause.getRiskItemList(); + for (RiskItem riskItemListRiskItem : riskItemList) { + riskItemListRiskItem.getCauseList().remove(cause); + riskItemListRiskItem = em.merge(riskItemListRiskItem); + } + em.remove(cause); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findCauseEntities() { + return findCauseEntities(true, -1, -1); + } + + public List findCauseEntities(int maxResults, int firstResult) { + return findCauseEntities(false, maxResults, firstResult); + } + + private List findCauseEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(Cause.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public Cause findCause(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(Cause.class, id); + } + finally { + em.close(); + } + } + + public int getCauseCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(Cause.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/CorrectiveActionJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/CorrectiveActionJpaController.java index 6e8a30b7..3f22d37b 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/CorrectiveActionJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/CorrectiveActionJpaController.java @@ -13,249 +13,249 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.CorrectiveAction; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.VmUser; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.ExceptionHasCorrectiveAction; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class CorrectiveActionJpaController implements Serializable { - - public CorrectiveActionJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(CorrectiveAction correctiveAction) { - if (correctiveAction.getVmUserList() == null) { - correctiveAction.setVmUserList(new ArrayList()); - } - if (correctiveAction.getExceptionHasCorrectiveActionList() == null) { - correctiveAction.setExceptionHasCorrectiveActionList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedVmUserList = new ArrayList(); - for (VmUser vmUserListVmUserToAttach : correctiveAction.getVmUserList()) { - vmUserListVmUserToAttach = em.getReference(vmUserListVmUserToAttach.getClass(), vmUserListVmUserToAttach.getId()); - attachedVmUserList.add(vmUserListVmUserToAttach); - } - correctiveAction.setVmUserList(attachedVmUserList); - List attachedExceptionHasCorrectiveActionList = new ArrayList(); - for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListExceptionHasCorrectiveActionToAttach : correctiveAction.getExceptionHasCorrectiveActionList()) { - exceptionHasCorrectiveActionListExceptionHasCorrectiveActionToAttach = em.getReference(exceptionHasCorrectiveActionListExceptionHasCorrectiveActionToAttach.getClass(), exceptionHasCorrectiveActionListExceptionHasCorrectiveActionToAttach.getExceptionHasCorrectiveActionPK()); - attachedExceptionHasCorrectiveActionList.add(exceptionHasCorrectiveActionListExceptionHasCorrectiveActionToAttach); - } - correctiveAction.setExceptionHasCorrectiveActionList(attachedExceptionHasCorrectiveActionList); - em.persist(correctiveAction); - for (VmUser vmUserListVmUser : correctiveAction.getVmUserList()) { - vmUserListVmUser.getCorrectiveActionList().add(correctiveAction); - vmUserListVmUser = em.merge(vmUserListVmUser); - } - for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListExceptionHasCorrectiveAction : correctiveAction.getExceptionHasCorrectiveActionList()) { - CorrectiveAction oldCorrectiveActionOfExceptionHasCorrectiveActionListExceptionHasCorrectiveAction = exceptionHasCorrectiveActionListExceptionHasCorrectiveAction.getCorrectiveAction(); - exceptionHasCorrectiveActionListExceptionHasCorrectiveAction.setCorrectiveAction(correctiveAction); - exceptionHasCorrectiveActionListExceptionHasCorrectiveAction = em.merge(exceptionHasCorrectiveActionListExceptionHasCorrectiveAction); - if (oldCorrectiveActionOfExceptionHasCorrectiveActionListExceptionHasCorrectiveAction != null) { - oldCorrectiveActionOfExceptionHasCorrectiveActionListExceptionHasCorrectiveAction.getExceptionHasCorrectiveActionList().remove(exceptionHasCorrectiveActionListExceptionHasCorrectiveAction); - oldCorrectiveActionOfExceptionHasCorrectiveActionListExceptionHasCorrectiveAction = em.merge(oldCorrectiveActionOfExceptionHasCorrectiveActionListExceptionHasCorrectiveAction); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(CorrectiveAction correctiveAction) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - CorrectiveAction persistentCorrectiveAction = em.find(CorrectiveAction.class, correctiveAction.getId()); - List vmUserListOld = persistentCorrectiveAction.getVmUserList(); - List vmUserListNew = correctiveAction.getVmUserList(); - List exceptionHasCorrectiveActionListOld = persistentCorrectiveAction.getExceptionHasCorrectiveActionList(); - List exceptionHasCorrectiveActionListNew = correctiveAction.getExceptionHasCorrectiveActionList(); - List illegalOrphanMessages = null; - for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListOldExceptionHasCorrectiveAction : exceptionHasCorrectiveActionListOld) { - if (!exceptionHasCorrectiveActionListNew.contains(exceptionHasCorrectiveActionListOldExceptionHasCorrectiveAction)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExceptionHasCorrectiveAction " + exceptionHasCorrectiveActionListOldExceptionHasCorrectiveAction + " since its correctiveAction field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedVmUserListNew = new ArrayList(); - for (VmUser vmUserListNewVmUserToAttach : vmUserListNew) { - vmUserListNewVmUserToAttach = em.getReference(vmUserListNewVmUserToAttach.getClass(), vmUserListNewVmUserToAttach.getId()); - attachedVmUserListNew.add(vmUserListNewVmUserToAttach); - } - vmUserListNew = attachedVmUserListNew; - correctiveAction.setVmUserList(vmUserListNew); - List attachedExceptionHasCorrectiveActionListNew = new ArrayList(); - for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListNewExceptionHasCorrectiveActionToAttach : exceptionHasCorrectiveActionListNew) { - exceptionHasCorrectiveActionListNewExceptionHasCorrectiveActionToAttach = em.getReference(exceptionHasCorrectiveActionListNewExceptionHasCorrectiveActionToAttach.getClass(), exceptionHasCorrectiveActionListNewExceptionHasCorrectiveActionToAttach.getExceptionHasCorrectiveActionPK()); - attachedExceptionHasCorrectiveActionListNew.add(exceptionHasCorrectiveActionListNewExceptionHasCorrectiveActionToAttach); - } - exceptionHasCorrectiveActionListNew = attachedExceptionHasCorrectiveActionListNew; - correctiveAction.setExceptionHasCorrectiveActionList(exceptionHasCorrectiveActionListNew); - correctiveAction = em.merge(correctiveAction); - for (VmUser vmUserListOldVmUser : vmUserListOld) { - if (!vmUserListNew.contains(vmUserListOldVmUser)) { - vmUserListOldVmUser.getCorrectiveActionList().remove(correctiveAction); - vmUserListOldVmUser = em.merge(vmUserListOldVmUser); - } - } - for (VmUser vmUserListNewVmUser : vmUserListNew) { - if (!vmUserListOld.contains(vmUserListNewVmUser)) { - vmUserListNewVmUser.getCorrectiveActionList().add(correctiveAction); - vmUserListNewVmUser = em.merge(vmUserListNewVmUser); - } - } - for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction : exceptionHasCorrectiveActionListNew) { - if (!exceptionHasCorrectiveActionListOld.contains(exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction)) { - CorrectiveAction oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction = exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction.getCorrectiveAction(); - exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction.setCorrectiveAction(correctiveAction); - exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction = em.merge(exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction); - if (oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction != null && !oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction.equals(correctiveAction)) { - oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction.getExceptionHasCorrectiveActionList().remove(exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction); - oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction = em.merge(oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = correctiveAction.getId(); - if (findCorrectiveAction(id) == null) { - throw new NonexistentEntityException("The correctiveAction with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - CorrectiveAction correctiveAction; - try { - correctiveAction = em.getReference(CorrectiveAction.class, id); - correctiveAction.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The correctiveAction with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List exceptionHasCorrectiveActionListOrphanCheck = correctiveAction.getExceptionHasCorrectiveActionList(); - for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListOrphanCheckExceptionHasCorrectiveAction : exceptionHasCorrectiveActionListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This CorrectiveAction (" + correctiveAction + ") cannot be destroyed since the ExceptionHasCorrectiveAction " + exceptionHasCorrectiveActionListOrphanCheckExceptionHasCorrectiveAction + " in its exceptionHasCorrectiveActionList field has a non-nullable correctiveAction field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List vmUserList = correctiveAction.getVmUserList(); - for (VmUser vmUserListVmUser : vmUserList) { - vmUserListVmUser.getCorrectiveActionList().remove(correctiveAction); - vmUserListVmUser = em.merge(vmUserListVmUser); - } - em.remove(correctiveAction); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findCorrectiveActionEntities() { - return findCorrectiveActionEntities(true, -1, -1); - } - - public List findCorrectiveActionEntities(int maxResults, int firstResult) { - return findCorrectiveActionEntities(false, maxResults, firstResult); - } - - private List findCorrectiveActionEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(CorrectiveAction.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public CorrectiveAction findCorrectiveAction(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(CorrectiveAction.class, id); - } - finally { - em.close(); - } - } - - public int getCorrectiveActionCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(CorrectiveAction.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.CorrectiveAction; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.VmUser; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.ExceptionHasCorrectiveAction; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class CorrectiveActionJpaController implements Serializable { + + public CorrectiveActionJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(CorrectiveAction correctiveAction) { + if (correctiveAction.getVmUserList() == null) { + correctiveAction.setVmUserList(new ArrayList<>()); + } + if (correctiveAction.getExceptionHasCorrectiveActionList() == null) { + correctiveAction.setExceptionHasCorrectiveActionList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedVmUserList = new ArrayList<>(); + for (VmUser vmUserListVmUserToAttach : correctiveAction.getVmUserList()) { + vmUserListVmUserToAttach = em.getReference(vmUserListVmUserToAttach.getClass(), vmUserListVmUserToAttach.getId()); + attachedVmUserList.add(vmUserListVmUserToAttach); + } + correctiveAction.setVmUserList(attachedVmUserList); + List attachedExceptionHasCorrectiveActionList = new ArrayList<>(); + for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListExceptionHasCorrectiveActionToAttach : correctiveAction.getExceptionHasCorrectiveActionList()) { + exceptionHasCorrectiveActionListExceptionHasCorrectiveActionToAttach = em.getReference(exceptionHasCorrectiveActionListExceptionHasCorrectiveActionToAttach.getClass(), exceptionHasCorrectiveActionListExceptionHasCorrectiveActionToAttach.getExceptionHasCorrectiveActionPK()); + attachedExceptionHasCorrectiveActionList.add(exceptionHasCorrectiveActionListExceptionHasCorrectiveActionToAttach); + } + correctiveAction.setExceptionHasCorrectiveActionList(attachedExceptionHasCorrectiveActionList); + em.persist(correctiveAction); + for (VmUser vmUserListVmUser : correctiveAction.getVmUserList()) { + vmUserListVmUser.getCorrectiveActionList().add(correctiveAction); + vmUserListVmUser = em.merge(vmUserListVmUser); + } + for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListExceptionHasCorrectiveAction : correctiveAction.getExceptionHasCorrectiveActionList()) { + CorrectiveAction oldCorrectiveActionOfExceptionHasCorrectiveActionListExceptionHasCorrectiveAction = exceptionHasCorrectiveActionListExceptionHasCorrectiveAction.getCorrectiveAction(); + exceptionHasCorrectiveActionListExceptionHasCorrectiveAction.setCorrectiveAction(correctiveAction); + exceptionHasCorrectiveActionListExceptionHasCorrectiveAction = em.merge(exceptionHasCorrectiveActionListExceptionHasCorrectiveAction); + if (oldCorrectiveActionOfExceptionHasCorrectiveActionListExceptionHasCorrectiveAction != null) { + oldCorrectiveActionOfExceptionHasCorrectiveActionListExceptionHasCorrectiveAction.getExceptionHasCorrectiveActionList().remove(exceptionHasCorrectiveActionListExceptionHasCorrectiveAction); + oldCorrectiveActionOfExceptionHasCorrectiveActionListExceptionHasCorrectiveAction = em.merge(oldCorrectiveActionOfExceptionHasCorrectiveActionListExceptionHasCorrectiveAction); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(CorrectiveAction correctiveAction) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + CorrectiveAction persistentCorrectiveAction = em.find(CorrectiveAction.class, correctiveAction.getId()); + List vmUserListOld = persistentCorrectiveAction.getVmUserList(); + List vmUserListNew = correctiveAction.getVmUserList(); + List exceptionHasCorrectiveActionListOld = persistentCorrectiveAction.getExceptionHasCorrectiveActionList(); + List exceptionHasCorrectiveActionListNew = correctiveAction.getExceptionHasCorrectiveActionList(); + List illegalOrphanMessages = null; + for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListOldExceptionHasCorrectiveAction : exceptionHasCorrectiveActionListOld) { + if (!exceptionHasCorrectiveActionListNew.contains(exceptionHasCorrectiveActionListOldExceptionHasCorrectiveAction)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExceptionHasCorrectiveAction " + exceptionHasCorrectiveActionListOldExceptionHasCorrectiveAction + " since its correctiveAction field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedVmUserListNew = new ArrayList<>(); + for (VmUser vmUserListNewVmUserToAttach : vmUserListNew) { + vmUserListNewVmUserToAttach = em.getReference(vmUserListNewVmUserToAttach.getClass(), vmUserListNewVmUserToAttach.getId()); + attachedVmUserListNew.add(vmUserListNewVmUserToAttach); + } + vmUserListNew = attachedVmUserListNew; + correctiveAction.setVmUserList(vmUserListNew); + List attachedExceptionHasCorrectiveActionListNew = new ArrayList<>(); + for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListNewExceptionHasCorrectiveActionToAttach : exceptionHasCorrectiveActionListNew) { + exceptionHasCorrectiveActionListNewExceptionHasCorrectiveActionToAttach = em.getReference(exceptionHasCorrectiveActionListNewExceptionHasCorrectiveActionToAttach.getClass(), exceptionHasCorrectiveActionListNewExceptionHasCorrectiveActionToAttach.getExceptionHasCorrectiveActionPK()); + attachedExceptionHasCorrectiveActionListNew.add(exceptionHasCorrectiveActionListNewExceptionHasCorrectiveActionToAttach); + } + exceptionHasCorrectiveActionListNew = attachedExceptionHasCorrectiveActionListNew; + correctiveAction.setExceptionHasCorrectiveActionList(exceptionHasCorrectiveActionListNew); + correctiveAction = em.merge(correctiveAction); + for (VmUser vmUserListOldVmUser : vmUserListOld) { + if (!vmUserListNew.contains(vmUserListOldVmUser)) { + vmUserListOldVmUser.getCorrectiveActionList().remove(correctiveAction); + vmUserListOldVmUser = em.merge(vmUserListOldVmUser); + } + } + for (VmUser vmUserListNewVmUser : vmUserListNew) { + if (!vmUserListOld.contains(vmUserListNewVmUser)) { + vmUserListNewVmUser.getCorrectiveActionList().add(correctiveAction); + vmUserListNewVmUser = em.merge(vmUserListNewVmUser); + } + } + for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction : exceptionHasCorrectiveActionListNew) { + if (!exceptionHasCorrectiveActionListOld.contains(exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction)) { + CorrectiveAction oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction = exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction.getCorrectiveAction(); + exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction.setCorrectiveAction(correctiveAction); + exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction = em.merge(exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction); + if (oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction != null && !oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction.equals(correctiveAction)) { + oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction.getExceptionHasCorrectiveActionList().remove(exceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction); + oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction = em.merge(oldCorrectiveActionOfExceptionHasCorrectiveActionListNewExceptionHasCorrectiveAction); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = correctiveAction.getId(); + if (findCorrectiveAction(id) == null) { + throw new NonexistentEntityException("The correctiveAction with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + CorrectiveAction correctiveAction; + try { + correctiveAction = em.getReference(CorrectiveAction.class, id); + correctiveAction.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The correctiveAction with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List exceptionHasCorrectiveActionListOrphanCheck = correctiveAction.getExceptionHasCorrectiveActionList(); + for (ExceptionHasCorrectiveAction exceptionHasCorrectiveActionListOrphanCheckExceptionHasCorrectiveAction : exceptionHasCorrectiveActionListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This CorrectiveAction (" + correctiveAction + ") cannot be destroyed since the ExceptionHasCorrectiveAction " + exceptionHasCorrectiveActionListOrphanCheckExceptionHasCorrectiveAction + " in its exceptionHasCorrectiveActionList field has a non-nullable correctiveAction field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List vmUserList = correctiveAction.getVmUserList(); + for (VmUser vmUserListVmUser : vmUserList) { + vmUserListVmUser.getCorrectiveActionList().remove(correctiveAction); + vmUserListVmUser = em.merge(vmUserListVmUser); + } + em.remove(correctiveAction); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findCorrectiveActionEntities() { + return findCorrectiveActionEntities(true, -1, -1); + } + + public List findCorrectiveActionEntities(int maxResults, int firstResult) { + return findCorrectiveActionEntities(false, maxResults, firstResult); + } + + private List findCorrectiveActionEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(CorrectiveAction.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public CorrectiveAction findCorrectiveAction(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(CorrectiveAction.class, id); + } + finally { + em.close(); + } + } + + public int getCorrectiveActionCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(CorrectiveAction.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionResultJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionResultJpaController.java index fb65a08c..9cc7c881 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionResultJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionResultJpaController.java @@ -13,196 +13,196 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.ExecutionResult; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class ExecutionResultJpaController implements Serializable { - - public ExecutionResultJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(ExecutionResult executionResult) { - if (executionResult.getExecutionStepList() == null) { - executionResult.setExecutionStepList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedExecutionStepList = new ArrayList(); - for (ExecutionStep executionStepListExecutionStepToAttach : executionResult.getExecutionStepList()) { - executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepList.add(executionStepListExecutionStepToAttach); - } - executionResult.setExecutionStepList(attachedExecutionStepList); - em.persist(executionResult); - for (ExecutionStep executionStepListExecutionStep : executionResult.getExecutionStepList()) { - ExecutionResult oldResultIdOfExecutionStepListExecutionStep = executionStepListExecutionStep.getResultId(); - executionStepListExecutionStep.setResultId(executionResult); - executionStepListExecutionStep = em.merge(executionStepListExecutionStep); - if (oldResultIdOfExecutionStepListExecutionStep != null) { - oldResultIdOfExecutionStepListExecutionStep.getExecutionStepList().remove(executionStepListExecutionStep); - oldResultIdOfExecutionStepListExecutionStep = em.merge(oldResultIdOfExecutionStepListExecutionStep); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(ExecutionResult executionResult) throws NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - ExecutionResult persistentExecutionResult = em.find(ExecutionResult.class, executionResult.getId()); - List executionStepListOld = persistentExecutionResult.getExecutionStepList(); - List executionStepListNew = executionResult.getExecutionStepList(); - List attachedExecutionStepListNew = new ArrayList(); - for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { - executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); - } - executionStepListNew = attachedExecutionStepListNew; - executionResult.setExecutionStepList(executionStepListNew); - executionResult = em.merge(executionResult); - for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { - if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { - executionStepListOldExecutionStep.setResultId(null); - executionStepListOldExecutionStep = em.merge(executionStepListOldExecutionStep); - } - } - for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { - if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { - ExecutionResult oldResultIdOfExecutionStepListNewExecutionStep = executionStepListNewExecutionStep.getResultId(); - executionStepListNewExecutionStep.setResultId(executionResult); - executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); - if (oldResultIdOfExecutionStepListNewExecutionStep != null && !oldResultIdOfExecutionStepListNewExecutionStep.equals(executionResult)) { - oldResultIdOfExecutionStepListNewExecutionStep.getExecutionStepList().remove(executionStepListNewExecutionStep); - oldResultIdOfExecutionStepListNewExecutionStep = em.merge(oldResultIdOfExecutionStepListNewExecutionStep); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = executionResult.getId(); - if (findExecutionResult(id) == null) { - throw new NonexistentEntityException("The executionResult with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - ExecutionResult executionResult; - try { - executionResult = em.getReference(ExecutionResult.class, id); - executionResult.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The executionResult with id " + id + " no longer exists.", enfe); - } - List executionStepList = executionResult.getExecutionStepList(); - for (ExecutionStep executionStepListExecutionStep : executionStepList) { - executionStepListExecutionStep.setResultId(null); - executionStepListExecutionStep = em.merge(executionStepListExecutionStep); - } - em.remove(executionResult); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findExecutionResultEntities() { - return findExecutionResultEntities(true, -1, -1); - } - - public List findExecutionResultEntities(int maxResults, int firstResult) { - return findExecutionResultEntities(false, maxResults, firstResult); - } - - private List findExecutionResultEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(ExecutionResult.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public ExecutionResult findExecutionResult(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(ExecutionResult.class, id); - } - finally { - em.close(); - } - } - - public int getExecutionResultCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(ExecutionResult.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.ExecutionResult; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ExecutionResultJpaController implements Serializable { + + public ExecutionResultJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(ExecutionResult executionResult) { + if (executionResult.getExecutionStepList() == null) { + executionResult.setExecutionStepList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedExecutionStepList = new ArrayList<>(); + for (ExecutionStep executionStepListExecutionStepToAttach : executionResult.getExecutionStepList()) { + executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepList.add(executionStepListExecutionStepToAttach); + } + executionResult.setExecutionStepList(attachedExecutionStepList); + em.persist(executionResult); + for (ExecutionStep executionStepListExecutionStep : executionResult.getExecutionStepList()) { + ExecutionResult oldResultIdOfExecutionStepListExecutionStep = executionStepListExecutionStep.getResultId(); + executionStepListExecutionStep.setResultId(executionResult); + executionStepListExecutionStep = em.merge(executionStepListExecutionStep); + if (oldResultIdOfExecutionStepListExecutionStep != null) { + oldResultIdOfExecutionStepListExecutionStep.getExecutionStepList().remove(executionStepListExecutionStep); + oldResultIdOfExecutionStepListExecutionStep = em.merge(oldResultIdOfExecutionStepListExecutionStep); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(ExecutionResult executionResult) throws NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + ExecutionResult persistentExecutionResult = em.find(ExecutionResult.class, executionResult.getId()); + List executionStepListOld = persistentExecutionResult.getExecutionStepList(); + List executionStepListNew = executionResult.getExecutionStepList(); + List attachedExecutionStepListNew = new ArrayList<>(); + for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { + executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); + } + executionStepListNew = attachedExecutionStepListNew; + executionResult.setExecutionStepList(executionStepListNew); + executionResult = em.merge(executionResult); + for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { + if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { + executionStepListOldExecutionStep.setResultId(null); + executionStepListOldExecutionStep = em.merge(executionStepListOldExecutionStep); + } + } + for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { + if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { + ExecutionResult oldResultIdOfExecutionStepListNewExecutionStep = executionStepListNewExecutionStep.getResultId(); + executionStepListNewExecutionStep.setResultId(executionResult); + executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); + if (oldResultIdOfExecutionStepListNewExecutionStep != null && !oldResultIdOfExecutionStepListNewExecutionStep.equals(executionResult)) { + oldResultIdOfExecutionStepListNewExecutionStep.getExecutionStepList().remove(executionStepListNewExecutionStep); + oldResultIdOfExecutionStepListNewExecutionStep = em.merge(oldResultIdOfExecutionStepListNewExecutionStep); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = executionResult.getId(); + if (findExecutionResult(id) == null) { + throw new NonexistentEntityException("The executionResult with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + ExecutionResult executionResult; + try { + executionResult = em.getReference(ExecutionResult.class, id); + executionResult.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The executionResult with id " + id + " no longer exists.", enfe); + } + List executionStepList = executionResult.getExecutionStepList(); + for (ExecutionStep executionStepListExecutionStep : executionStepList) { + executionStepListExecutionStep.setResultId(null); + executionStepListExecutionStep = em.merge(executionStepListExecutionStep); + } + em.remove(executionResult); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findExecutionResultEntities() { + return findExecutionResultEntities(true, -1, -1); + } + + public List findExecutionResultEntities(int maxResults, int firstResult) { + return findExecutionResultEntities(false, maxResults, firstResult); + } + + private List findExecutionResultEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(ExecutionResult.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public ExecutionResult findExecutionResult(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(ExecutionResult.class, id); + } + finally { + em.close(); + } + } + + public int getExecutionResultCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(ExecutionResult.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionStepHasIssueJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionStepHasIssueJpaController.java index b285713e..c0612ae2 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionStepHasIssueJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionStepHasIssueJpaController.java @@ -13,265 +13,265 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.ExecutionStepHasIssue; -import com.validation.manager.core.db.ExecutionStepHasIssuePK; -import com.validation.manager.core.db.Issue; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class ExecutionStepHasIssueJpaController implements Serializable { - - public ExecutionStepHasIssueJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(ExecutionStepHasIssue executionStepHasIssue) throws PreexistingEntityException, Exception { - if (executionStepHasIssue.getExecutionStepHasIssuePK() == null) { - executionStepHasIssue.setExecutionStepHasIssuePK(new ExecutionStepHasIssuePK()); - } - if (executionStepHasIssue.getVmUserList() == null) { - executionStepHasIssue.setVmUserList(new ArrayList()); - } - executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepStepTestCaseId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getStepTestCaseId()); - executionStepHasIssue.getExecutionStepHasIssuePK().setIssueId(executionStepHasIssue.getIssue().getIssuePK().getId()); - executionStepHasIssue.getExecutionStepHasIssuePK().setIssueIssueTypeId(executionStepHasIssue.getIssue().getIssuePK().getIssueTypeId()); - executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepTestCaseExecutionId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getTestCaseExecutionId()); - executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepStepId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getStepId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - ExecutionStep executionStep = executionStepHasIssue.getExecutionStep(); - if (executionStep != null) { - executionStep = em.getReference(executionStep.getClass(), executionStep.getExecutionStepPK()); - executionStepHasIssue.setExecutionStep(executionStep); - } - Issue issue = executionStepHasIssue.getIssue(); - if (issue != null) { - issue = em.getReference(issue.getClass(), issue.getIssuePK()); - executionStepHasIssue.setIssue(issue); - } - List attachedVmUserList = new ArrayList(); - for (VmUser vmUserListVmUserToAttach : executionStepHasIssue.getVmUserList()) { - vmUserListVmUserToAttach = em.getReference(vmUserListVmUserToAttach.getClass(), vmUserListVmUserToAttach.getId()); - attachedVmUserList.add(vmUserListVmUserToAttach); - } - executionStepHasIssue.setVmUserList(attachedVmUserList); - em.persist(executionStepHasIssue); - if (executionStep != null) { - executionStep.getExecutionStepHasIssueList().add(executionStepHasIssue); - executionStep = em.merge(executionStep); - } - if (issue != null) { - issue.getExecutionStepHasIssueList().add(executionStepHasIssue); - issue = em.merge(issue); - } - for (VmUser vmUserListVmUser : executionStepHasIssue.getVmUserList()) { - vmUserListVmUser.getExecutionStepHasIssueList().add(executionStepHasIssue); - vmUserListVmUser = em.merge(vmUserListVmUser); - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findExecutionStepHasIssue(executionStepHasIssue.getExecutionStepHasIssuePK()) != null) { - throw new PreexistingEntityException("ExecutionStepHasIssue " + executionStepHasIssue + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(ExecutionStepHasIssue executionStepHasIssue) throws NonexistentEntityException, Exception { - executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepStepTestCaseId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getStepTestCaseId()); - executionStepHasIssue.getExecutionStepHasIssuePK().setIssueId(executionStepHasIssue.getIssue().getIssuePK().getId()); - executionStepHasIssue.getExecutionStepHasIssuePK().setIssueIssueTypeId(executionStepHasIssue.getIssue().getIssuePK().getIssueTypeId()); - executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepTestCaseExecutionId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getTestCaseExecutionId()); - executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepStepId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getStepId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - ExecutionStepHasIssue persistentExecutionStepHasIssue = em.find(ExecutionStepHasIssue.class, executionStepHasIssue.getExecutionStepHasIssuePK()); - ExecutionStep executionStepOld = persistentExecutionStepHasIssue.getExecutionStep(); - ExecutionStep executionStepNew = executionStepHasIssue.getExecutionStep(); - Issue issueOld = persistentExecutionStepHasIssue.getIssue(); - Issue issueNew = executionStepHasIssue.getIssue(); - List vmUserListOld = persistentExecutionStepHasIssue.getVmUserList(); - List vmUserListNew = executionStepHasIssue.getVmUserList(); - if (executionStepNew != null) { - executionStepNew = em.getReference(executionStepNew.getClass(), executionStepNew.getExecutionStepPK()); - executionStepHasIssue.setExecutionStep(executionStepNew); - } - if (issueNew != null) { - issueNew = em.getReference(issueNew.getClass(), issueNew.getIssuePK()); - executionStepHasIssue.setIssue(issueNew); - } - List attachedVmUserListNew = new ArrayList(); - for (VmUser vmUserListNewVmUserToAttach : vmUserListNew) { - vmUserListNewVmUserToAttach = em.getReference(vmUserListNewVmUserToAttach.getClass(), vmUserListNewVmUserToAttach.getId()); - attachedVmUserListNew.add(vmUserListNewVmUserToAttach); - } - vmUserListNew = attachedVmUserListNew; - executionStepHasIssue.setVmUserList(vmUserListNew); - executionStepHasIssue = em.merge(executionStepHasIssue); - if (executionStepOld != null && !executionStepOld.equals(executionStepNew)) { - executionStepOld.getExecutionStepHasIssueList().remove(executionStepHasIssue); - executionStepOld = em.merge(executionStepOld); - } - if (executionStepNew != null && !executionStepNew.equals(executionStepOld)) { - executionStepNew.getExecutionStepHasIssueList().add(executionStepHasIssue); - executionStepNew = em.merge(executionStepNew); - } - if (issueOld != null && !issueOld.equals(issueNew)) { - issueOld.getExecutionStepHasIssueList().remove(executionStepHasIssue); - issueOld = em.merge(issueOld); - } - if (issueNew != null && !issueNew.equals(issueOld)) { - issueNew.getExecutionStepHasIssueList().add(executionStepHasIssue); - issueNew = em.merge(issueNew); - } - for (VmUser vmUserListOldVmUser : vmUserListOld) { - if (!vmUserListNew.contains(vmUserListOldVmUser)) { - vmUserListOldVmUser.getExecutionStepHasIssueList().remove(executionStepHasIssue); - vmUserListOldVmUser = em.merge(vmUserListOldVmUser); - } - } - for (VmUser vmUserListNewVmUser : vmUserListNew) { - if (!vmUserListOld.contains(vmUserListNewVmUser)) { - vmUserListNewVmUser.getExecutionStepHasIssueList().add(executionStepHasIssue); - vmUserListNewVmUser = em.merge(vmUserListNewVmUser); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - ExecutionStepHasIssuePK id = executionStepHasIssue.getExecutionStepHasIssuePK(); - if (findExecutionStepHasIssue(id) == null) { - throw new NonexistentEntityException("The executionStepHasIssue with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(ExecutionStepHasIssuePK id) throws NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - ExecutionStepHasIssue executionStepHasIssue; - try { - executionStepHasIssue = em.getReference(ExecutionStepHasIssue.class, id); - executionStepHasIssue.getExecutionStepHasIssuePK(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The executionStepHasIssue with id " + id + " no longer exists.", enfe); - } - ExecutionStep executionStep = executionStepHasIssue.getExecutionStep(); - if (executionStep != null) { - executionStep.getExecutionStepHasIssueList().remove(executionStepHasIssue); - executionStep = em.merge(executionStep); - } - Issue issue = executionStepHasIssue.getIssue(); - if (issue != null) { - issue.getExecutionStepHasIssueList().remove(executionStepHasIssue); - issue = em.merge(issue); - } - List vmUserList = executionStepHasIssue.getVmUserList(); - for (VmUser vmUserListVmUser : vmUserList) { - vmUserListVmUser.getExecutionStepHasIssueList().remove(executionStepHasIssue); - vmUserListVmUser = em.merge(vmUserListVmUser); - } - em.remove(executionStepHasIssue); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findExecutionStepHasIssueEntities() { - return findExecutionStepHasIssueEntities(true, -1, -1); - } - - public List findExecutionStepHasIssueEntities(int maxResults, int firstResult) { - return findExecutionStepHasIssueEntities(false, maxResults, firstResult); - } - - private List findExecutionStepHasIssueEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(ExecutionStepHasIssue.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public ExecutionStepHasIssue findExecutionStepHasIssue(ExecutionStepHasIssuePK id) { - EntityManager em = getEntityManager(); - try { - return em.find(ExecutionStepHasIssue.class, id); - } - finally { - em.close(); - } - } - - public int getExecutionStepHasIssueCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(ExecutionStepHasIssue.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.ExecutionStepHasIssue; +import com.validation.manager.core.db.ExecutionStepHasIssuePK; +import com.validation.manager.core.db.Issue; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ExecutionStepHasIssueJpaController implements Serializable { + + public ExecutionStepHasIssueJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(ExecutionStepHasIssue executionStepHasIssue) throws PreexistingEntityException, Exception { + if (executionStepHasIssue.getExecutionStepHasIssuePK() == null) { + executionStepHasIssue.setExecutionStepHasIssuePK(new ExecutionStepHasIssuePK()); + } + if (executionStepHasIssue.getVmUserList() == null) { + executionStepHasIssue.setVmUserList(new ArrayList<>()); + } + executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepStepTestCaseId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getStepTestCaseId()); + executionStepHasIssue.getExecutionStepHasIssuePK().setIssueId(executionStepHasIssue.getIssue().getIssuePK().getId()); + executionStepHasIssue.getExecutionStepHasIssuePK().setIssueIssueTypeId(executionStepHasIssue.getIssue().getIssuePK().getIssueTypeId()); + executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepTestCaseExecutionId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getTestCaseExecutionId()); + executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepStepId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getStepId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + ExecutionStep executionStep = executionStepHasIssue.getExecutionStep(); + if (executionStep != null) { + executionStep = em.getReference(executionStep.getClass(), executionStep.getExecutionStepPK()); + executionStepHasIssue.setExecutionStep(executionStep); + } + Issue issue = executionStepHasIssue.getIssue(); + if (issue != null) { + issue = em.getReference(issue.getClass(), issue.getIssuePK()); + executionStepHasIssue.setIssue(issue); + } + List attachedVmUserList = new ArrayList<>(); + for (VmUser vmUserListVmUserToAttach : executionStepHasIssue.getVmUserList()) { + vmUserListVmUserToAttach = em.getReference(vmUserListVmUserToAttach.getClass(), vmUserListVmUserToAttach.getId()); + attachedVmUserList.add(vmUserListVmUserToAttach); + } + executionStepHasIssue.setVmUserList(attachedVmUserList); + em.persist(executionStepHasIssue); + if (executionStep != null) { + executionStep.getExecutionStepHasIssueList().add(executionStepHasIssue); + executionStep = em.merge(executionStep); + } + if (issue != null) { + issue.getExecutionStepHasIssueList().add(executionStepHasIssue); + issue = em.merge(issue); + } + for (VmUser vmUserListVmUser : executionStepHasIssue.getVmUserList()) { + vmUserListVmUser.getExecutionStepHasIssueList().add(executionStepHasIssue); + vmUserListVmUser = em.merge(vmUserListVmUser); + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findExecutionStepHasIssue(executionStepHasIssue.getExecutionStepHasIssuePK()) != null) { + throw new PreexistingEntityException("ExecutionStepHasIssue " + executionStepHasIssue + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(ExecutionStepHasIssue executionStepHasIssue) throws NonexistentEntityException, Exception { + executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepStepTestCaseId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getStepTestCaseId()); + executionStepHasIssue.getExecutionStepHasIssuePK().setIssueId(executionStepHasIssue.getIssue().getIssuePK().getId()); + executionStepHasIssue.getExecutionStepHasIssuePK().setIssueIssueTypeId(executionStepHasIssue.getIssue().getIssuePK().getIssueTypeId()); + executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepTestCaseExecutionId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getTestCaseExecutionId()); + executionStepHasIssue.getExecutionStepHasIssuePK().setExecutionStepStepId(executionStepHasIssue.getExecutionStep().getExecutionStepPK().getStepId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + ExecutionStepHasIssue persistentExecutionStepHasIssue = em.find(ExecutionStepHasIssue.class, executionStepHasIssue.getExecutionStepHasIssuePK()); + ExecutionStep executionStepOld = persistentExecutionStepHasIssue.getExecutionStep(); + ExecutionStep executionStepNew = executionStepHasIssue.getExecutionStep(); + Issue issueOld = persistentExecutionStepHasIssue.getIssue(); + Issue issueNew = executionStepHasIssue.getIssue(); + List vmUserListOld = persistentExecutionStepHasIssue.getVmUserList(); + List vmUserListNew = executionStepHasIssue.getVmUserList(); + if (executionStepNew != null) { + executionStepNew = em.getReference(executionStepNew.getClass(), executionStepNew.getExecutionStepPK()); + executionStepHasIssue.setExecutionStep(executionStepNew); + } + if (issueNew != null) { + issueNew = em.getReference(issueNew.getClass(), issueNew.getIssuePK()); + executionStepHasIssue.setIssue(issueNew); + } + List attachedVmUserListNew = new ArrayList<>(); + for (VmUser vmUserListNewVmUserToAttach : vmUserListNew) { + vmUserListNewVmUserToAttach = em.getReference(vmUserListNewVmUserToAttach.getClass(), vmUserListNewVmUserToAttach.getId()); + attachedVmUserListNew.add(vmUserListNewVmUserToAttach); + } + vmUserListNew = attachedVmUserListNew; + executionStepHasIssue.setVmUserList(vmUserListNew); + executionStepHasIssue = em.merge(executionStepHasIssue); + if (executionStepOld != null && !executionStepOld.equals(executionStepNew)) { + executionStepOld.getExecutionStepHasIssueList().remove(executionStepHasIssue); + executionStepOld = em.merge(executionStepOld); + } + if (executionStepNew != null && !executionStepNew.equals(executionStepOld)) { + executionStepNew.getExecutionStepHasIssueList().add(executionStepHasIssue); + executionStepNew = em.merge(executionStepNew); + } + if (issueOld != null && !issueOld.equals(issueNew)) { + issueOld.getExecutionStepHasIssueList().remove(executionStepHasIssue); + issueOld = em.merge(issueOld); + } + if (issueNew != null && !issueNew.equals(issueOld)) { + issueNew.getExecutionStepHasIssueList().add(executionStepHasIssue); + issueNew = em.merge(issueNew); + } + for (VmUser vmUserListOldVmUser : vmUserListOld) { + if (!vmUserListNew.contains(vmUserListOldVmUser)) { + vmUserListOldVmUser.getExecutionStepHasIssueList().remove(executionStepHasIssue); + vmUserListOldVmUser = em.merge(vmUserListOldVmUser); + } + } + for (VmUser vmUserListNewVmUser : vmUserListNew) { + if (!vmUserListOld.contains(vmUserListNewVmUser)) { + vmUserListNewVmUser.getExecutionStepHasIssueList().add(executionStepHasIssue); + vmUserListNewVmUser = em.merge(vmUserListNewVmUser); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + ExecutionStepHasIssuePK id = executionStepHasIssue.getExecutionStepHasIssuePK(); + if (findExecutionStepHasIssue(id) == null) { + throw new NonexistentEntityException("The executionStepHasIssue with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(ExecutionStepHasIssuePK id) throws NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + ExecutionStepHasIssue executionStepHasIssue; + try { + executionStepHasIssue = em.getReference(ExecutionStepHasIssue.class, id); + executionStepHasIssue.getExecutionStepHasIssuePK(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The executionStepHasIssue with id " + id + " no longer exists.", enfe); + } + ExecutionStep executionStep = executionStepHasIssue.getExecutionStep(); + if (executionStep != null) { + executionStep.getExecutionStepHasIssueList().remove(executionStepHasIssue); + executionStep = em.merge(executionStep); + } + Issue issue = executionStepHasIssue.getIssue(); + if (issue != null) { + issue.getExecutionStepHasIssueList().remove(executionStepHasIssue); + issue = em.merge(issue); + } + List vmUserList = executionStepHasIssue.getVmUserList(); + for (VmUser vmUserListVmUser : vmUserList) { + vmUserListVmUser.getExecutionStepHasIssueList().remove(executionStepHasIssue); + vmUserListVmUser = em.merge(vmUserListVmUser); + } + em.remove(executionStepHasIssue); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findExecutionStepHasIssueEntities() { + return findExecutionStepHasIssueEntities(true, -1, -1); + } + + public List findExecutionStepHasIssueEntities(int maxResults, int firstResult) { + return findExecutionStepHasIssueEntities(false, maxResults, firstResult); + } + + private List findExecutionStepHasIssueEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(ExecutionStepHasIssue.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public ExecutionStepHasIssue findExecutionStepHasIssue(ExecutionStepHasIssuePK id) { + EntityManager em = getEntityManager(); + try { + return em.find(ExecutionStepHasIssue.class, id); + } + finally { + em.close(); + } + } + + public int getExecutionStepHasIssueCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(ExecutionStepHasIssue.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionStepJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionStepJpaController.java index 53b13aa6..0b924133 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionStepJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/ExecutionStepJpaController.java @@ -13,603 +13,603 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.ExecutionResult; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.ReviewResult; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.Step; -import com.validation.manager.core.db.TestCaseExecution; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.ExecutionStepHasAttachment; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.ExecutionStepHasIssue; -import com.validation.manager.core.db.ExecutionStepHasVmUser; -import com.validation.manager.core.db.ExecutionStepPK; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class ExecutionStepJpaController implements Serializable { - - public ExecutionStepJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(ExecutionStep executionStep) throws PreexistingEntityException, Exception { - if (executionStep.getExecutionStepPK() == null) { - executionStep.setExecutionStepPK(new ExecutionStepPK()); - } - if (executionStep.getExecutionStepHasAttachmentList() == null) { - executionStep.setExecutionStepHasAttachmentList(new ArrayList()); - } - if (executionStep.getExecutionStepHasIssueList() == null) { - executionStep.setExecutionStepHasIssueList(new ArrayList()); - } - if (executionStep.getExecutionStepHasVmUserList() == null) { - executionStep.setExecutionStepHasVmUserList(new ArrayList()); - } - if (executionStep.getHistoryList() == null) { - executionStep.setHistoryList(new ArrayList()); - } - executionStep.getExecutionStepPK().setTestCaseExecutionId(executionStep.getTestCaseExecution().getId()); - executionStep.getExecutionStepPK().setStepTestCaseId(executionStep.getStep().getStepPK().getTestCaseId()); - executionStep.getExecutionStepPK().setStepId(executionStep.getStep().getStepPK().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - ExecutionResult resultId = executionStep.getResultId(); - if (resultId != null) { - resultId = em.getReference(resultId.getClass(), resultId.getId()); - executionStep.setResultId(resultId); - } - ReviewResult reviewResultId = executionStep.getReviewResultId(); - if (reviewResultId != null) { - reviewResultId = em.getReference(reviewResultId.getClass(), reviewResultId.getId()); - executionStep.setReviewResultId(reviewResultId); - } - VmUser assignee = executionStep.getAssignee(); - if (assignee != null) { - assignee = em.getReference(assignee.getClass(), assignee.getId()); - executionStep.setAssignee(assignee); - } - VmUser assigner = executionStep.getAssigner(); - if (assigner != null) { - assigner = em.getReference(assigner.getClass(), assigner.getId()); - executionStep.setAssigner(assigner); - } - Step step = executionStep.getStep(); - if (step != null) { - step = em.getReference(step.getClass(), step.getStepPK()); - executionStep.setStep(step); - } - TestCaseExecution testCaseExecution = executionStep.getTestCaseExecution(); - if (testCaseExecution != null) { - testCaseExecution = em.getReference(testCaseExecution.getClass(), testCaseExecution.getId()); - executionStep.setTestCaseExecution(testCaseExecution); - } - VmUser reviewer = executionStep.getReviewer(); - if (reviewer != null) { - reviewer = em.getReference(reviewer.getClass(), reviewer.getId()); - executionStep.setReviewer(reviewer); - } - History stepHistory = executionStep.getStepHistory(); - if (stepHistory != null) { - stepHistory = em.getReference(stepHistory.getClass(), stepHistory.getId()); - executionStep.setStepHistory(stepHistory); - } - List attachedExecutionStepHasAttachmentList = new ArrayList(); - for (ExecutionStepHasAttachment executionStepHasAttachmentListExecutionStepHasAttachmentToAttach : executionStep.getExecutionStepHasAttachmentList()) { - executionStepHasAttachmentListExecutionStepHasAttachmentToAttach = em.getReference(executionStepHasAttachmentListExecutionStepHasAttachmentToAttach.getClass(), executionStepHasAttachmentListExecutionStepHasAttachmentToAttach.getExecutionStepHasAttachmentPK()); - attachedExecutionStepHasAttachmentList.add(executionStepHasAttachmentListExecutionStepHasAttachmentToAttach); - } - executionStep.setExecutionStepHasAttachmentList(attachedExecutionStepHasAttachmentList); - List attachedExecutionStepHasIssueList = new ArrayList(); - for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssueToAttach : executionStep.getExecutionStepHasIssueList()) { - executionStepHasIssueListExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); - attachedExecutionStepHasIssueList.add(executionStepHasIssueListExecutionStepHasIssueToAttach); - } - executionStep.setExecutionStepHasIssueList(attachedExecutionStepHasIssueList); - List attachedExecutionStepHasVmUserList = new ArrayList(); - for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUserToAttach : executionStep.getExecutionStepHasVmUserList()) { - executionStepHasVmUserListExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); - attachedExecutionStepHasVmUserList.add(executionStepHasVmUserListExecutionStepHasVmUserToAttach); - } - executionStep.setExecutionStepHasVmUserList(attachedExecutionStepHasVmUserList); - List attachedHistoryList = new ArrayList(); - for (History historyListHistoryToAttach : executionStep.getHistoryList()) { - historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); - attachedHistoryList.add(historyListHistoryToAttach); - } - executionStep.setHistoryList(attachedHistoryList); - em.persist(executionStep); - if (resultId != null) { - resultId.getExecutionStepList().add(executionStep); - resultId = em.merge(resultId); - } - if (reviewResultId != null) { - reviewResultId.getExecutionStepList().add(executionStep); - reviewResultId = em.merge(reviewResultId); - } - if (assignee != null) { - assignee.getExecutionStepList().add(executionStep); - assignee = em.merge(assignee); - } - if (assigner != null) { - assigner.getExecutionStepList().add(executionStep); - assigner = em.merge(assigner); - } - if (step != null) { - step.getExecutionStepList().add(executionStep); - step = em.merge(step); - } - if (testCaseExecution != null) { - testCaseExecution.getExecutionStepList().add(executionStep); - testCaseExecution = em.merge(testCaseExecution); - } - if (reviewer != null) { - reviewer.getExecutionStepList().add(executionStep); - reviewer = em.merge(reviewer); - } - if (stepHistory != null) { - stepHistory.getExecutionStepList().add(executionStep); - stepHistory = em.merge(stepHistory); - } - for (ExecutionStepHasAttachment executionStepHasAttachmentListExecutionStepHasAttachment : executionStep.getExecutionStepHasAttachmentList()) { - ExecutionStep oldExecutionStepOfExecutionStepHasAttachmentListExecutionStepHasAttachment = executionStepHasAttachmentListExecutionStepHasAttachment.getExecutionStep(); - executionStepHasAttachmentListExecutionStepHasAttachment.setExecutionStep(executionStep); - executionStepHasAttachmentListExecutionStepHasAttachment = em.merge(executionStepHasAttachmentListExecutionStepHasAttachment); - if (oldExecutionStepOfExecutionStepHasAttachmentListExecutionStepHasAttachment != null) { - oldExecutionStepOfExecutionStepHasAttachmentListExecutionStepHasAttachment.getExecutionStepHasAttachmentList().remove(executionStepHasAttachmentListExecutionStepHasAttachment); - oldExecutionStepOfExecutionStepHasAttachmentListExecutionStepHasAttachment = em.merge(oldExecutionStepOfExecutionStepHasAttachmentListExecutionStepHasAttachment); - } - } - for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssue : executionStep.getExecutionStepHasIssueList()) { - ExecutionStep oldExecutionStepOfExecutionStepHasIssueListExecutionStepHasIssue = executionStepHasIssueListExecutionStepHasIssue.getExecutionStep(); - executionStepHasIssueListExecutionStepHasIssue.setExecutionStep(executionStep); - executionStepHasIssueListExecutionStepHasIssue = em.merge(executionStepHasIssueListExecutionStepHasIssue); - if (oldExecutionStepOfExecutionStepHasIssueListExecutionStepHasIssue != null) { - oldExecutionStepOfExecutionStepHasIssueListExecutionStepHasIssue.getExecutionStepHasIssueList().remove(executionStepHasIssueListExecutionStepHasIssue); - oldExecutionStepOfExecutionStepHasIssueListExecutionStepHasIssue = em.merge(oldExecutionStepOfExecutionStepHasIssueListExecutionStepHasIssue); - } - } - for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUser : executionStep.getExecutionStepHasVmUserList()) { - ExecutionStep oldExecutionStepOfExecutionStepHasVmUserListExecutionStepHasVmUser = executionStepHasVmUserListExecutionStepHasVmUser.getExecutionStep(); - executionStepHasVmUserListExecutionStepHasVmUser.setExecutionStep(executionStep); - executionStepHasVmUserListExecutionStepHasVmUser = em.merge(executionStepHasVmUserListExecutionStepHasVmUser); - if (oldExecutionStepOfExecutionStepHasVmUserListExecutionStepHasVmUser != null) { - oldExecutionStepOfExecutionStepHasVmUserListExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListExecutionStepHasVmUser); - oldExecutionStepOfExecutionStepHasVmUserListExecutionStepHasVmUser = em.merge(oldExecutionStepOfExecutionStepHasVmUserListExecutionStepHasVmUser); - } - } - for (History historyListHistory : executionStep.getHistoryList()) { - historyListHistory.getExecutionStepList().add(executionStep); - historyListHistory = em.merge(historyListHistory); - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findExecutionStep(executionStep.getExecutionStepPK()) != null) { - throw new PreexistingEntityException("ExecutionStep " + executionStep + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(ExecutionStep executionStep) throws IllegalOrphanException, NonexistentEntityException, Exception { - executionStep.getExecutionStepPK().setTestCaseExecutionId(executionStep.getTestCaseExecution().getId()); - executionStep.getExecutionStepPK().setStepTestCaseId(executionStep.getStep().getStepPK().getTestCaseId()); - executionStep.getExecutionStepPK().setStepId(executionStep.getStep().getStepPK().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - ExecutionStep persistentExecutionStep = em.find(ExecutionStep.class, executionStep.getExecutionStepPK()); - ExecutionResult resultIdOld = persistentExecutionStep.getResultId(); - ExecutionResult resultIdNew = executionStep.getResultId(); - ReviewResult reviewResultIdOld = persistentExecutionStep.getReviewResultId(); - ReviewResult reviewResultIdNew = executionStep.getReviewResultId(); - VmUser assigneeOld = persistentExecutionStep.getAssignee(); - VmUser assigneeNew = executionStep.getAssignee(); - VmUser assignerOld = persistentExecutionStep.getAssigner(); - VmUser assignerNew = executionStep.getAssigner(); - Step stepOld = persistentExecutionStep.getStep(); - Step stepNew = executionStep.getStep(); - TestCaseExecution testCaseExecutionOld = persistentExecutionStep.getTestCaseExecution(); - TestCaseExecution testCaseExecutionNew = executionStep.getTestCaseExecution(); - VmUser reviewerOld = persistentExecutionStep.getReviewer(); - VmUser reviewerNew = executionStep.getReviewer(); - History stepHistoryOld = persistentExecutionStep.getStepHistory(); - History stepHistoryNew = executionStep.getStepHistory(); - List executionStepHasAttachmentListOld = persistentExecutionStep.getExecutionStepHasAttachmentList(); - List executionStepHasAttachmentListNew = executionStep.getExecutionStepHasAttachmentList(); - List executionStepHasIssueListOld = persistentExecutionStep.getExecutionStepHasIssueList(); - List executionStepHasIssueListNew = executionStep.getExecutionStepHasIssueList(); - List executionStepHasVmUserListOld = persistentExecutionStep.getExecutionStepHasVmUserList(); - List executionStepHasVmUserListNew = executionStep.getExecutionStepHasVmUserList(); - List historyListOld = persistentExecutionStep.getHistoryList(); - List historyListNew = executionStep.getHistoryList(); - List illegalOrphanMessages = null; - for (ExecutionStepHasAttachment executionStepHasAttachmentListOldExecutionStepHasAttachment : executionStepHasAttachmentListOld) { - if (!executionStepHasAttachmentListNew.contains(executionStepHasAttachmentListOldExecutionStepHasAttachment)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExecutionStepHasAttachment " + executionStepHasAttachmentListOldExecutionStepHasAttachment + " since its executionStep field is not nullable."); - } - } - for (ExecutionStepHasIssue executionStepHasIssueListOldExecutionStepHasIssue : executionStepHasIssueListOld) { - if (!executionStepHasIssueListNew.contains(executionStepHasIssueListOldExecutionStepHasIssue)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExecutionStepHasIssue " + executionStepHasIssueListOldExecutionStepHasIssue + " since its executionStep field is not nullable."); - } - } - for (ExecutionStepHasVmUser executionStepHasVmUserListOldExecutionStepHasVmUser : executionStepHasVmUserListOld) { - if (!executionStepHasVmUserListNew.contains(executionStepHasVmUserListOldExecutionStepHasVmUser)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExecutionStepHasVmUser " + executionStepHasVmUserListOldExecutionStepHasVmUser + " since its executionStep field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (resultIdNew != null) { - resultIdNew = em.getReference(resultIdNew.getClass(), resultIdNew.getId()); - executionStep.setResultId(resultIdNew); - } - if (reviewResultIdNew != null) { - reviewResultIdNew = em.getReference(reviewResultIdNew.getClass(), reviewResultIdNew.getId()); - executionStep.setReviewResultId(reviewResultIdNew); - } - if (assigneeNew != null) { - assigneeNew = em.getReference(assigneeNew.getClass(), assigneeNew.getId()); - executionStep.setAssignee(assigneeNew); - } - if (assignerNew != null) { - assignerNew = em.getReference(assignerNew.getClass(), assignerNew.getId()); - executionStep.setAssigner(assignerNew); - } - if (stepNew != null) { - stepNew = em.getReference(stepNew.getClass(), stepNew.getStepPK()); - executionStep.setStep(stepNew); - } - if (testCaseExecutionNew != null) { - testCaseExecutionNew = em.getReference(testCaseExecutionNew.getClass(), testCaseExecutionNew.getId()); - executionStep.setTestCaseExecution(testCaseExecutionNew); - } - if (reviewerNew != null) { - reviewerNew = em.getReference(reviewerNew.getClass(), reviewerNew.getId()); - executionStep.setReviewer(reviewerNew); - } - if (stepHistoryNew != null) { - stepHistoryNew = em.getReference(stepHistoryNew.getClass(), stepHistoryNew.getId()); - executionStep.setStepHistory(stepHistoryNew); - } - List attachedExecutionStepHasAttachmentListNew = new ArrayList(); - for (ExecutionStepHasAttachment executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach : executionStepHasAttachmentListNew) { - executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach = em.getReference(executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach.getClass(), executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach.getExecutionStepHasAttachmentPK()); - attachedExecutionStepHasAttachmentListNew.add(executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach); - } - executionStepHasAttachmentListNew = attachedExecutionStepHasAttachmentListNew; - executionStep.setExecutionStepHasAttachmentList(executionStepHasAttachmentListNew); - List attachedExecutionStepHasIssueListNew = new ArrayList(); - for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssueToAttach : executionStepHasIssueListNew) { - executionStepHasIssueListNewExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListNewExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListNewExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); - attachedExecutionStepHasIssueListNew.add(executionStepHasIssueListNewExecutionStepHasIssueToAttach); - } - executionStepHasIssueListNew = attachedExecutionStepHasIssueListNew; - executionStep.setExecutionStepHasIssueList(executionStepHasIssueListNew); - List attachedExecutionStepHasVmUserListNew = new ArrayList(); - for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUserToAttach : executionStepHasVmUserListNew) { - executionStepHasVmUserListNewExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); - attachedExecutionStepHasVmUserListNew.add(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach); - } - executionStepHasVmUserListNew = attachedExecutionStepHasVmUserListNew; - executionStep.setExecutionStepHasVmUserList(executionStepHasVmUserListNew); - List attachedHistoryListNew = new ArrayList(); - for (History historyListNewHistoryToAttach : historyListNew) { - historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); - attachedHistoryListNew.add(historyListNewHistoryToAttach); - } - historyListNew = attachedHistoryListNew; - executionStep.setHistoryList(historyListNew); - executionStep = em.merge(executionStep); - if (resultIdOld != null && !resultIdOld.equals(resultIdNew)) { - resultIdOld.getExecutionStepList().remove(executionStep); - resultIdOld = em.merge(resultIdOld); - } - if (resultIdNew != null && !resultIdNew.equals(resultIdOld)) { - resultIdNew.getExecutionStepList().add(executionStep); - resultIdNew = em.merge(resultIdNew); - } - if (reviewResultIdOld != null && !reviewResultIdOld.equals(reviewResultIdNew)) { - reviewResultIdOld.getExecutionStepList().remove(executionStep); - reviewResultIdOld = em.merge(reviewResultIdOld); - } - if (reviewResultIdNew != null && !reviewResultIdNew.equals(reviewResultIdOld)) { - reviewResultIdNew.getExecutionStepList().add(executionStep); - reviewResultIdNew = em.merge(reviewResultIdNew); - } - if (assigneeOld != null && !assigneeOld.equals(assigneeNew)) { - assigneeOld.getExecutionStepList().remove(executionStep); - assigneeOld = em.merge(assigneeOld); - } - if (assigneeNew != null && !assigneeNew.equals(assigneeOld)) { - assigneeNew.getExecutionStepList().add(executionStep); - assigneeNew = em.merge(assigneeNew); - } - if (assignerOld != null && !assignerOld.equals(assignerNew)) { - assignerOld.getExecutionStepList().remove(executionStep); - assignerOld = em.merge(assignerOld); - } - if (assignerNew != null && !assignerNew.equals(assignerOld)) { - assignerNew.getExecutionStepList().add(executionStep); - assignerNew = em.merge(assignerNew); - } - if (stepOld != null && !stepOld.equals(stepNew)) { - stepOld.getExecutionStepList().remove(executionStep); - stepOld = em.merge(stepOld); - } - if (stepNew != null && !stepNew.equals(stepOld)) { - stepNew.getExecutionStepList().add(executionStep); - stepNew = em.merge(stepNew); - } - if (testCaseExecutionOld != null && !testCaseExecutionOld.equals(testCaseExecutionNew)) { - testCaseExecutionOld.getExecutionStepList().remove(executionStep); - testCaseExecutionOld = em.merge(testCaseExecutionOld); - } - if (testCaseExecutionNew != null && !testCaseExecutionNew.equals(testCaseExecutionOld)) { - testCaseExecutionNew.getExecutionStepList().add(executionStep); - testCaseExecutionNew = em.merge(testCaseExecutionNew); - } - if (reviewerOld != null && !reviewerOld.equals(reviewerNew)) { - reviewerOld.getExecutionStepList().remove(executionStep); - reviewerOld = em.merge(reviewerOld); - } - if (reviewerNew != null && !reviewerNew.equals(reviewerOld)) { - reviewerNew.getExecutionStepList().add(executionStep); - reviewerNew = em.merge(reviewerNew); - } - if (stepHistoryOld != null && !stepHistoryOld.equals(stepHistoryNew)) { - stepHistoryOld.getExecutionStepList().remove(executionStep); - stepHistoryOld = em.merge(stepHistoryOld); - } - if (stepHistoryNew != null && !stepHistoryNew.equals(stepHistoryOld)) { - stepHistoryNew.getExecutionStepList().add(executionStep); - stepHistoryNew = em.merge(stepHistoryNew); - } - for (ExecutionStepHasAttachment executionStepHasAttachmentListNewExecutionStepHasAttachment : executionStepHasAttachmentListNew) { - if (!executionStepHasAttachmentListOld.contains(executionStepHasAttachmentListNewExecutionStepHasAttachment)) { - ExecutionStep oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment = executionStepHasAttachmentListNewExecutionStepHasAttachment.getExecutionStep(); - executionStepHasAttachmentListNewExecutionStepHasAttachment.setExecutionStep(executionStep); - executionStepHasAttachmentListNewExecutionStepHasAttachment = em.merge(executionStepHasAttachmentListNewExecutionStepHasAttachment); - if (oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment != null && !oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment.equals(executionStep)) { - oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment.getExecutionStepHasAttachmentList().remove(executionStepHasAttachmentListNewExecutionStepHasAttachment); - oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment = em.merge(oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment); - } - } - } - for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssue : executionStepHasIssueListNew) { - if (!executionStepHasIssueListOld.contains(executionStepHasIssueListNewExecutionStepHasIssue)) { - ExecutionStep oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue = executionStepHasIssueListNewExecutionStepHasIssue.getExecutionStep(); - executionStepHasIssueListNewExecutionStepHasIssue.setExecutionStep(executionStep); - executionStepHasIssueListNewExecutionStepHasIssue = em.merge(executionStepHasIssueListNewExecutionStepHasIssue); - if (oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue != null && !oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue.equals(executionStep)) { - oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue.getExecutionStepHasIssueList().remove(executionStepHasIssueListNewExecutionStepHasIssue); - oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue = em.merge(oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue); - } - } - } - for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUser : executionStepHasVmUserListNew) { - if (!executionStepHasVmUserListOld.contains(executionStepHasVmUserListNewExecutionStepHasVmUser)) { - ExecutionStep oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = executionStepHasVmUserListNewExecutionStepHasVmUser.getExecutionStep(); - executionStepHasVmUserListNewExecutionStepHasVmUser.setExecutionStep(executionStep); - executionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(executionStepHasVmUserListNewExecutionStepHasVmUser); - if (oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser != null && !oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.equals(executionStep)) { - oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListNewExecutionStepHasVmUser); - oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser); - } - } - } - for (History historyListOldHistory : historyListOld) { - if (!historyListNew.contains(historyListOldHistory)) { - historyListOldHistory.getExecutionStepList().remove(executionStep); - historyListOldHistory = em.merge(historyListOldHistory); - } - } - for (History historyListNewHistory : historyListNew) { - if (!historyListOld.contains(historyListNewHistory)) { - historyListNewHistory.getExecutionStepList().add(executionStep); - historyListNewHistory = em.merge(historyListNewHistory); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - ExecutionStepPK id = executionStep.getExecutionStepPK(); - if (findExecutionStep(id) == null) { - throw new NonexistentEntityException("The executionStep with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(ExecutionStepPK id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - ExecutionStep executionStep; - try { - executionStep = em.getReference(ExecutionStep.class, id); - executionStep.getExecutionStepPK(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The executionStep with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List executionStepHasAttachmentListOrphanCheck = executionStep.getExecutionStepHasAttachmentList(); - for (ExecutionStepHasAttachment executionStepHasAttachmentListOrphanCheckExecutionStepHasAttachment : executionStepHasAttachmentListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This ExecutionStep (" + executionStep + ") cannot be destroyed since the ExecutionStepHasAttachment " + executionStepHasAttachmentListOrphanCheckExecutionStepHasAttachment + " in its executionStepHasAttachmentList field has a non-nullable executionStep field."); - } - List executionStepHasIssueListOrphanCheck = executionStep.getExecutionStepHasIssueList(); - for (ExecutionStepHasIssue executionStepHasIssueListOrphanCheckExecutionStepHasIssue : executionStepHasIssueListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This ExecutionStep (" + executionStep + ") cannot be destroyed since the ExecutionStepHasIssue " + executionStepHasIssueListOrphanCheckExecutionStepHasIssue + " in its executionStepHasIssueList field has a non-nullable executionStep field."); - } - List executionStepHasVmUserListOrphanCheck = executionStep.getExecutionStepHasVmUserList(); - for (ExecutionStepHasVmUser executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser : executionStepHasVmUserListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This ExecutionStep (" + executionStep + ") cannot be destroyed since the ExecutionStepHasVmUser " + executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser + " in its executionStepHasVmUserList field has a non-nullable executionStep field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - ExecutionResult resultId = executionStep.getResultId(); - if (resultId != null) { - resultId.getExecutionStepList().remove(executionStep); - resultId = em.merge(resultId); - } - ReviewResult reviewResultId = executionStep.getReviewResultId(); - if (reviewResultId != null) { - reviewResultId.getExecutionStepList().remove(executionStep); - reviewResultId = em.merge(reviewResultId); - } - VmUser assignee = executionStep.getAssignee(); - if (assignee != null) { - assignee.getExecutionStepList().remove(executionStep); - assignee = em.merge(assignee); - } - VmUser assigner = executionStep.getAssigner(); - if (assigner != null) { - assigner.getExecutionStepList().remove(executionStep); - assigner = em.merge(assigner); - } - Step step = executionStep.getStep(); - if (step != null) { - step.getExecutionStepList().remove(executionStep); - step = em.merge(step); - } - TestCaseExecution testCaseExecution = executionStep.getTestCaseExecution(); - if (testCaseExecution != null) { - testCaseExecution.getExecutionStepList().remove(executionStep); - testCaseExecution = em.merge(testCaseExecution); - } - VmUser reviewer = executionStep.getReviewer(); - if (reviewer != null) { - reviewer.getExecutionStepList().remove(executionStep); - reviewer = em.merge(reviewer); - } - History stepHistory = executionStep.getStepHistory(); - if (stepHistory != null) { - stepHistory.getExecutionStepList().remove(executionStep); - stepHistory = em.merge(stepHistory); - } - List historyList = executionStep.getHistoryList(); - for (History historyListHistory : historyList) { - historyListHistory.getExecutionStepList().remove(executionStep); - historyListHistory = em.merge(historyListHistory); - } - em.remove(executionStep); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findExecutionStepEntities() { - return findExecutionStepEntities(true, -1, -1); - } - - public List findExecutionStepEntities(int maxResults, int firstResult) { - return findExecutionStepEntities(false, maxResults, firstResult); - } - - private List findExecutionStepEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(ExecutionStep.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public ExecutionStep findExecutionStep(ExecutionStepPK id) { - EntityManager em = getEntityManager(); - try { - return em.find(ExecutionStep.class, id); - } - finally { - em.close(); - } - } - - public int getExecutionStepCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(ExecutionStep.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.ExecutionResult; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.ReviewResult; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.Step; +import com.validation.manager.core.db.TestCaseExecution; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.ExecutionStepHasAttachment; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.ExecutionStepHasIssue; +import com.validation.manager.core.db.ExecutionStepHasVmUser; +import com.validation.manager.core.db.ExecutionStepPK; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ExecutionStepJpaController implements Serializable { + + public ExecutionStepJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(ExecutionStep executionStep) throws PreexistingEntityException, Exception { + if (executionStep.getExecutionStepPK() == null) { + executionStep.setExecutionStepPK(new ExecutionStepPK()); + } + if (executionStep.getExecutionStepHasAttachmentList() == null) { + executionStep.setExecutionStepHasAttachmentList(new ArrayList<>()); + } + if (executionStep.getExecutionStepHasIssueList() == null) { + executionStep.setExecutionStepHasIssueList(new ArrayList<>()); + } + if (executionStep.getExecutionStepHasVmUserList() == null) { + executionStep.setExecutionStepHasVmUserList(new ArrayList<>()); + } + if (executionStep.getHistoryList() == null) { + executionStep.setHistoryList(new ArrayList<>()); + } + executionStep.getExecutionStepPK().setTestCaseExecutionId(executionStep.getTestCaseExecution().getId()); + executionStep.getExecutionStepPK().setStepTestCaseId(executionStep.getStep().getStepPK().getTestCaseId()); + executionStep.getExecutionStepPK().setStepId(executionStep.getStep().getStepPK().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + ExecutionResult resultId = executionStep.getResultId(); + if (resultId != null) { + resultId = em.getReference(resultId.getClass(), resultId.getId()); + executionStep.setResultId(resultId); + } + ReviewResult reviewResultId = executionStep.getReviewResultId(); + if (reviewResultId != null) { + reviewResultId = em.getReference(reviewResultId.getClass(), reviewResultId.getId()); + executionStep.setReviewResultId(reviewResultId); + } + VmUser assignee = executionStep.getAssignee(); + if (assignee != null) { + assignee = em.getReference(assignee.getClass(), assignee.getId()); + executionStep.setAssignee(assignee); + } + VmUser assigner = executionStep.getAssigner(); + if (assigner != null) { + assigner = em.getReference(assigner.getClass(), assigner.getId()); + executionStep.setAssigner(assigner); + } + Step step = executionStep.getStep(); + if (step != null) { + step = em.getReference(step.getClass(), step.getStepPK()); + executionStep.setStep(step); + } + TestCaseExecution testCaseExecution = executionStep.getTestCaseExecution(); + if (testCaseExecution != null) { + testCaseExecution = em.getReference(testCaseExecution.getClass(), testCaseExecution.getId()); + executionStep.setTestCaseExecution(testCaseExecution); + } + VmUser reviewer = executionStep.getReviewer(); + if (reviewer != null) { + reviewer = em.getReference(reviewer.getClass(), reviewer.getId()); + executionStep.setReviewer(reviewer); + } + History stepHistory = executionStep.getStepHistory(); + if (stepHistory != null) { + stepHistory = em.getReference(stepHistory.getClass(), stepHistory.getId()); + executionStep.setStepHistory(stepHistory); + } + List attachedExecutionStepHasAttachmentList = new ArrayList<>(); + for (ExecutionStepHasAttachment executionStepHasAttachmentListExecutionStepHasAttachmentToAttach : executionStep.getExecutionStepHasAttachmentList()) { + executionStepHasAttachmentListExecutionStepHasAttachmentToAttach = em.getReference(executionStepHasAttachmentListExecutionStepHasAttachmentToAttach.getClass(), executionStepHasAttachmentListExecutionStepHasAttachmentToAttach.getExecutionStepHasAttachmentPK()); + attachedExecutionStepHasAttachmentList.add(executionStepHasAttachmentListExecutionStepHasAttachmentToAttach); + } + executionStep.setExecutionStepHasAttachmentList(attachedExecutionStepHasAttachmentList); + List attachedExecutionStepHasIssueList = new ArrayList<>(); + for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssueToAttach : executionStep.getExecutionStepHasIssueList()) { + executionStepHasIssueListExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); + attachedExecutionStepHasIssueList.add(executionStepHasIssueListExecutionStepHasIssueToAttach); + } + executionStep.setExecutionStepHasIssueList(attachedExecutionStepHasIssueList); + List attachedExecutionStepHasVmUserList = new ArrayList<>(); + for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUserToAttach : executionStep.getExecutionStepHasVmUserList()) { + executionStepHasVmUserListExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); + attachedExecutionStepHasVmUserList.add(executionStepHasVmUserListExecutionStepHasVmUserToAttach); + } + executionStep.setExecutionStepHasVmUserList(attachedExecutionStepHasVmUserList); + List attachedHistoryList = new ArrayList<>(); + for (History historyListHistoryToAttach : executionStep.getHistoryList()) { + historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); + attachedHistoryList.add(historyListHistoryToAttach); + } + executionStep.setHistoryList(attachedHistoryList); + em.persist(executionStep); + if (resultId != null) { + resultId.getExecutionStepList().add(executionStep); + resultId = em.merge(resultId); + } + if (reviewResultId != null) { + reviewResultId.getExecutionStepList().add(executionStep); + reviewResultId = em.merge(reviewResultId); + } + if (assignee != null) { + assignee.getExecutionStepList().add(executionStep); + assignee = em.merge(assignee); + } + if (assigner != null) { + assigner.getExecutionStepList().add(executionStep); + assigner = em.merge(assigner); + } + if (step != null) { + step.getExecutionStepList().add(executionStep); + step = em.merge(step); + } + if (testCaseExecution != null) { + testCaseExecution.getExecutionStepList().add(executionStep); + testCaseExecution = em.merge(testCaseExecution); + } + if (reviewer != null) { + reviewer.getExecutionStepList().add(executionStep); + reviewer = em.merge(reviewer); + } + if (stepHistory != null) { + stepHistory.getExecutionStepList().add(executionStep); + stepHistory = em.merge(stepHistory); + } + for (ExecutionStepHasAttachment executionStepHasAttachmentListExecutionStepHasAttachment : executionStep.getExecutionStepHasAttachmentList()) { + ExecutionStep oldExecutionStepOfExecutionStepHasAttachmentListExecutionStepHasAttachment = executionStepHasAttachmentListExecutionStepHasAttachment.getExecutionStep(); + executionStepHasAttachmentListExecutionStepHasAttachment.setExecutionStep(executionStep); + executionStepHasAttachmentListExecutionStepHasAttachment = em.merge(executionStepHasAttachmentListExecutionStepHasAttachment); + if (oldExecutionStepOfExecutionStepHasAttachmentListExecutionStepHasAttachment != null) { + oldExecutionStepOfExecutionStepHasAttachmentListExecutionStepHasAttachment.getExecutionStepHasAttachmentList().remove(executionStepHasAttachmentListExecutionStepHasAttachment); + oldExecutionStepOfExecutionStepHasAttachmentListExecutionStepHasAttachment = em.merge(oldExecutionStepOfExecutionStepHasAttachmentListExecutionStepHasAttachment); + } + } + for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssue : executionStep.getExecutionStepHasIssueList()) { + ExecutionStep oldExecutionStepOfExecutionStepHasIssueListExecutionStepHasIssue = executionStepHasIssueListExecutionStepHasIssue.getExecutionStep(); + executionStepHasIssueListExecutionStepHasIssue.setExecutionStep(executionStep); + executionStepHasIssueListExecutionStepHasIssue = em.merge(executionStepHasIssueListExecutionStepHasIssue); + if (oldExecutionStepOfExecutionStepHasIssueListExecutionStepHasIssue != null) { + oldExecutionStepOfExecutionStepHasIssueListExecutionStepHasIssue.getExecutionStepHasIssueList().remove(executionStepHasIssueListExecutionStepHasIssue); + oldExecutionStepOfExecutionStepHasIssueListExecutionStepHasIssue = em.merge(oldExecutionStepOfExecutionStepHasIssueListExecutionStepHasIssue); + } + } + for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUser : executionStep.getExecutionStepHasVmUserList()) { + ExecutionStep oldExecutionStepOfExecutionStepHasVmUserListExecutionStepHasVmUser = executionStepHasVmUserListExecutionStepHasVmUser.getExecutionStep(); + executionStepHasVmUserListExecutionStepHasVmUser.setExecutionStep(executionStep); + executionStepHasVmUserListExecutionStepHasVmUser = em.merge(executionStepHasVmUserListExecutionStepHasVmUser); + if (oldExecutionStepOfExecutionStepHasVmUserListExecutionStepHasVmUser != null) { + oldExecutionStepOfExecutionStepHasVmUserListExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListExecutionStepHasVmUser); + oldExecutionStepOfExecutionStepHasVmUserListExecutionStepHasVmUser = em.merge(oldExecutionStepOfExecutionStepHasVmUserListExecutionStepHasVmUser); + } + } + for (History historyListHistory : executionStep.getHistoryList()) { + historyListHistory.getExecutionStepList().add(executionStep); + historyListHistory = em.merge(historyListHistory); + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findExecutionStep(executionStep.getExecutionStepPK()) != null) { + throw new PreexistingEntityException("ExecutionStep " + executionStep + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(ExecutionStep executionStep) throws IllegalOrphanException, NonexistentEntityException, Exception { + executionStep.getExecutionStepPK().setTestCaseExecutionId(executionStep.getTestCaseExecution().getId()); + executionStep.getExecutionStepPK().setStepTestCaseId(executionStep.getStep().getStepPK().getTestCaseId()); + executionStep.getExecutionStepPK().setStepId(executionStep.getStep().getStepPK().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + ExecutionStep persistentExecutionStep = em.find(ExecutionStep.class, executionStep.getExecutionStepPK()); + ExecutionResult resultIdOld = persistentExecutionStep.getResultId(); + ExecutionResult resultIdNew = executionStep.getResultId(); + ReviewResult reviewResultIdOld = persistentExecutionStep.getReviewResultId(); + ReviewResult reviewResultIdNew = executionStep.getReviewResultId(); + VmUser assigneeOld = persistentExecutionStep.getAssignee(); + VmUser assigneeNew = executionStep.getAssignee(); + VmUser assignerOld = persistentExecutionStep.getAssigner(); + VmUser assignerNew = executionStep.getAssigner(); + Step stepOld = persistentExecutionStep.getStep(); + Step stepNew = executionStep.getStep(); + TestCaseExecution testCaseExecutionOld = persistentExecutionStep.getTestCaseExecution(); + TestCaseExecution testCaseExecutionNew = executionStep.getTestCaseExecution(); + VmUser reviewerOld = persistentExecutionStep.getReviewer(); + VmUser reviewerNew = executionStep.getReviewer(); + History stepHistoryOld = persistentExecutionStep.getStepHistory(); + History stepHistoryNew = executionStep.getStepHistory(); + List executionStepHasAttachmentListOld = persistentExecutionStep.getExecutionStepHasAttachmentList(); + List executionStepHasAttachmentListNew = executionStep.getExecutionStepHasAttachmentList(); + List executionStepHasIssueListOld = persistentExecutionStep.getExecutionStepHasIssueList(); + List executionStepHasIssueListNew = executionStep.getExecutionStepHasIssueList(); + List executionStepHasVmUserListOld = persistentExecutionStep.getExecutionStepHasVmUserList(); + List executionStepHasVmUserListNew = executionStep.getExecutionStepHasVmUserList(); + List historyListOld = persistentExecutionStep.getHistoryList(); + List historyListNew = executionStep.getHistoryList(); + List illegalOrphanMessages = null; + for (ExecutionStepHasAttachment executionStepHasAttachmentListOldExecutionStepHasAttachment : executionStepHasAttachmentListOld) { + if (!executionStepHasAttachmentListNew.contains(executionStepHasAttachmentListOldExecutionStepHasAttachment)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExecutionStepHasAttachment " + executionStepHasAttachmentListOldExecutionStepHasAttachment + " since its executionStep field is not nullable."); + } + } + for (ExecutionStepHasIssue executionStepHasIssueListOldExecutionStepHasIssue : executionStepHasIssueListOld) { + if (!executionStepHasIssueListNew.contains(executionStepHasIssueListOldExecutionStepHasIssue)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExecutionStepHasIssue " + executionStepHasIssueListOldExecutionStepHasIssue + " since its executionStep field is not nullable."); + } + } + for (ExecutionStepHasVmUser executionStepHasVmUserListOldExecutionStepHasVmUser : executionStepHasVmUserListOld) { + if (!executionStepHasVmUserListNew.contains(executionStepHasVmUserListOldExecutionStepHasVmUser)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExecutionStepHasVmUser " + executionStepHasVmUserListOldExecutionStepHasVmUser + " since its executionStep field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (resultIdNew != null) { + resultIdNew = em.getReference(resultIdNew.getClass(), resultIdNew.getId()); + executionStep.setResultId(resultIdNew); + } + if (reviewResultIdNew != null) { + reviewResultIdNew = em.getReference(reviewResultIdNew.getClass(), reviewResultIdNew.getId()); + executionStep.setReviewResultId(reviewResultIdNew); + } + if (assigneeNew != null) { + assigneeNew = em.getReference(assigneeNew.getClass(), assigneeNew.getId()); + executionStep.setAssignee(assigneeNew); + } + if (assignerNew != null) { + assignerNew = em.getReference(assignerNew.getClass(), assignerNew.getId()); + executionStep.setAssigner(assignerNew); + } + if (stepNew != null) { + stepNew = em.getReference(stepNew.getClass(), stepNew.getStepPK()); + executionStep.setStep(stepNew); + } + if (testCaseExecutionNew != null) { + testCaseExecutionNew = em.getReference(testCaseExecutionNew.getClass(), testCaseExecutionNew.getId()); + executionStep.setTestCaseExecution(testCaseExecutionNew); + } + if (reviewerNew != null) { + reviewerNew = em.getReference(reviewerNew.getClass(), reviewerNew.getId()); + executionStep.setReviewer(reviewerNew); + } + if (stepHistoryNew != null) { + stepHistoryNew = em.getReference(stepHistoryNew.getClass(), stepHistoryNew.getId()); + executionStep.setStepHistory(stepHistoryNew); + } + List attachedExecutionStepHasAttachmentListNew = new ArrayList<>(); + for (ExecutionStepHasAttachment executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach : executionStepHasAttachmentListNew) { + executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach = em.getReference(executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach.getClass(), executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach.getExecutionStepHasAttachmentPK()); + attachedExecutionStepHasAttachmentListNew.add(executionStepHasAttachmentListNewExecutionStepHasAttachmentToAttach); + } + executionStepHasAttachmentListNew = attachedExecutionStepHasAttachmentListNew; + executionStep.setExecutionStepHasAttachmentList(executionStepHasAttachmentListNew); + List attachedExecutionStepHasIssueListNew = new ArrayList<>(); + for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssueToAttach : executionStepHasIssueListNew) { + executionStepHasIssueListNewExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListNewExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListNewExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); + attachedExecutionStepHasIssueListNew.add(executionStepHasIssueListNewExecutionStepHasIssueToAttach); + } + executionStepHasIssueListNew = attachedExecutionStepHasIssueListNew; + executionStep.setExecutionStepHasIssueList(executionStepHasIssueListNew); + List attachedExecutionStepHasVmUserListNew = new ArrayList<>(); + for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUserToAttach : executionStepHasVmUserListNew) { + executionStepHasVmUserListNewExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); + attachedExecutionStepHasVmUserListNew.add(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach); + } + executionStepHasVmUserListNew = attachedExecutionStepHasVmUserListNew; + executionStep.setExecutionStepHasVmUserList(executionStepHasVmUserListNew); + List attachedHistoryListNew = new ArrayList<>(); + for (History historyListNewHistoryToAttach : historyListNew) { + historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); + attachedHistoryListNew.add(historyListNewHistoryToAttach); + } + historyListNew = attachedHistoryListNew; + executionStep.setHistoryList(historyListNew); + executionStep = em.merge(executionStep); + if (resultIdOld != null && !resultIdOld.equals(resultIdNew)) { + resultIdOld.getExecutionStepList().remove(executionStep); + resultIdOld = em.merge(resultIdOld); + } + if (resultIdNew != null && !resultIdNew.equals(resultIdOld)) { + resultIdNew.getExecutionStepList().add(executionStep); + resultIdNew = em.merge(resultIdNew); + } + if (reviewResultIdOld != null && !reviewResultIdOld.equals(reviewResultIdNew)) { + reviewResultIdOld.getExecutionStepList().remove(executionStep); + reviewResultIdOld = em.merge(reviewResultIdOld); + } + if (reviewResultIdNew != null && !reviewResultIdNew.equals(reviewResultIdOld)) { + reviewResultIdNew.getExecutionStepList().add(executionStep); + reviewResultIdNew = em.merge(reviewResultIdNew); + } + if (assigneeOld != null && !assigneeOld.equals(assigneeNew)) { + assigneeOld.getExecutionStepList().remove(executionStep); + assigneeOld = em.merge(assigneeOld); + } + if (assigneeNew != null && !assigneeNew.equals(assigneeOld)) { + assigneeNew.getExecutionStepList().add(executionStep); + assigneeNew = em.merge(assigneeNew); + } + if (assignerOld != null && !assignerOld.equals(assignerNew)) { + assignerOld.getExecutionStepList().remove(executionStep); + assignerOld = em.merge(assignerOld); + } + if (assignerNew != null && !assignerNew.equals(assignerOld)) { + assignerNew.getExecutionStepList().add(executionStep); + assignerNew = em.merge(assignerNew); + } + if (stepOld != null && !stepOld.equals(stepNew)) { + stepOld.getExecutionStepList().remove(executionStep); + stepOld = em.merge(stepOld); + } + if (stepNew != null && !stepNew.equals(stepOld)) { + stepNew.getExecutionStepList().add(executionStep); + stepNew = em.merge(stepNew); + } + if (testCaseExecutionOld != null && !testCaseExecutionOld.equals(testCaseExecutionNew)) { + testCaseExecutionOld.getExecutionStepList().remove(executionStep); + testCaseExecutionOld = em.merge(testCaseExecutionOld); + } + if (testCaseExecutionNew != null && !testCaseExecutionNew.equals(testCaseExecutionOld)) { + testCaseExecutionNew.getExecutionStepList().add(executionStep); + testCaseExecutionNew = em.merge(testCaseExecutionNew); + } + if (reviewerOld != null && !reviewerOld.equals(reviewerNew)) { + reviewerOld.getExecutionStepList().remove(executionStep); + reviewerOld = em.merge(reviewerOld); + } + if (reviewerNew != null && !reviewerNew.equals(reviewerOld)) { + reviewerNew.getExecutionStepList().add(executionStep); + reviewerNew = em.merge(reviewerNew); + } + if (stepHistoryOld != null && !stepHistoryOld.equals(stepHistoryNew)) { + stepHistoryOld.getExecutionStepList().remove(executionStep); + stepHistoryOld = em.merge(stepHistoryOld); + } + if (stepHistoryNew != null && !stepHistoryNew.equals(stepHistoryOld)) { + stepHistoryNew.getExecutionStepList().add(executionStep); + stepHistoryNew = em.merge(stepHistoryNew); + } + for (ExecutionStepHasAttachment executionStepHasAttachmentListNewExecutionStepHasAttachment : executionStepHasAttachmentListNew) { + if (!executionStepHasAttachmentListOld.contains(executionStepHasAttachmentListNewExecutionStepHasAttachment)) { + ExecutionStep oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment = executionStepHasAttachmentListNewExecutionStepHasAttachment.getExecutionStep(); + executionStepHasAttachmentListNewExecutionStepHasAttachment.setExecutionStep(executionStep); + executionStepHasAttachmentListNewExecutionStepHasAttachment = em.merge(executionStepHasAttachmentListNewExecutionStepHasAttachment); + if (oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment != null && !oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment.equals(executionStep)) { + oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment.getExecutionStepHasAttachmentList().remove(executionStepHasAttachmentListNewExecutionStepHasAttachment); + oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment = em.merge(oldExecutionStepOfExecutionStepHasAttachmentListNewExecutionStepHasAttachment); + } + } + } + for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssue : executionStepHasIssueListNew) { + if (!executionStepHasIssueListOld.contains(executionStepHasIssueListNewExecutionStepHasIssue)) { + ExecutionStep oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue = executionStepHasIssueListNewExecutionStepHasIssue.getExecutionStep(); + executionStepHasIssueListNewExecutionStepHasIssue.setExecutionStep(executionStep); + executionStepHasIssueListNewExecutionStepHasIssue = em.merge(executionStepHasIssueListNewExecutionStepHasIssue); + if (oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue != null && !oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue.equals(executionStep)) { + oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue.getExecutionStepHasIssueList().remove(executionStepHasIssueListNewExecutionStepHasIssue); + oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue = em.merge(oldExecutionStepOfExecutionStepHasIssueListNewExecutionStepHasIssue); + } + } + } + for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUser : executionStepHasVmUserListNew) { + if (!executionStepHasVmUserListOld.contains(executionStepHasVmUserListNewExecutionStepHasVmUser)) { + ExecutionStep oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = executionStepHasVmUserListNewExecutionStepHasVmUser.getExecutionStep(); + executionStepHasVmUserListNewExecutionStepHasVmUser.setExecutionStep(executionStep); + executionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(executionStepHasVmUserListNewExecutionStepHasVmUser); + if (oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser != null && !oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.equals(executionStep)) { + oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListNewExecutionStepHasVmUser); + oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(oldExecutionStepOfExecutionStepHasVmUserListNewExecutionStepHasVmUser); + } + } + } + for (History historyListOldHistory : historyListOld) { + if (!historyListNew.contains(historyListOldHistory)) { + historyListOldHistory.getExecutionStepList().remove(executionStep); + historyListOldHistory = em.merge(historyListOldHistory); + } + } + for (History historyListNewHistory : historyListNew) { + if (!historyListOld.contains(historyListNewHistory)) { + historyListNewHistory.getExecutionStepList().add(executionStep); + historyListNewHistory = em.merge(historyListNewHistory); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + ExecutionStepPK id = executionStep.getExecutionStepPK(); + if (findExecutionStep(id) == null) { + throw new NonexistentEntityException("The executionStep with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(ExecutionStepPK id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + ExecutionStep executionStep; + try { + executionStep = em.getReference(ExecutionStep.class, id); + executionStep.getExecutionStepPK(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The executionStep with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List executionStepHasAttachmentListOrphanCheck = executionStep.getExecutionStepHasAttachmentList(); + for (ExecutionStepHasAttachment executionStepHasAttachmentListOrphanCheckExecutionStepHasAttachment : executionStepHasAttachmentListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This ExecutionStep (" + executionStep + ") cannot be destroyed since the ExecutionStepHasAttachment " + executionStepHasAttachmentListOrphanCheckExecutionStepHasAttachment + " in its executionStepHasAttachmentList field has a non-nullable executionStep field."); + } + List executionStepHasIssueListOrphanCheck = executionStep.getExecutionStepHasIssueList(); + for (ExecutionStepHasIssue executionStepHasIssueListOrphanCheckExecutionStepHasIssue : executionStepHasIssueListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This ExecutionStep (" + executionStep + ") cannot be destroyed since the ExecutionStepHasIssue " + executionStepHasIssueListOrphanCheckExecutionStepHasIssue + " in its executionStepHasIssueList field has a non-nullable executionStep field."); + } + List executionStepHasVmUserListOrphanCheck = executionStep.getExecutionStepHasVmUserList(); + for (ExecutionStepHasVmUser executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser : executionStepHasVmUserListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This ExecutionStep (" + executionStep + ") cannot be destroyed since the ExecutionStepHasVmUser " + executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser + " in its executionStepHasVmUserList field has a non-nullable executionStep field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + ExecutionResult resultId = executionStep.getResultId(); + if (resultId != null) { + resultId.getExecutionStepList().remove(executionStep); + resultId = em.merge(resultId); + } + ReviewResult reviewResultId = executionStep.getReviewResultId(); + if (reviewResultId != null) { + reviewResultId.getExecutionStepList().remove(executionStep); + reviewResultId = em.merge(reviewResultId); + } + VmUser assignee = executionStep.getAssignee(); + if (assignee != null) { + assignee.getExecutionStepList().remove(executionStep); + assignee = em.merge(assignee); + } + VmUser assigner = executionStep.getAssigner(); + if (assigner != null) { + assigner.getExecutionStepList().remove(executionStep); + assigner = em.merge(assigner); + } + Step step = executionStep.getStep(); + if (step != null) { + step.getExecutionStepList().remove(executionStep); + step = em.merge(step); + } + TestCaseExecution testCaseExecution = executionStep.getTestCaseExecution(); + if (testCaseExecution != null) { + testCaseExecution.getExecutionStepList().remove(executionStep); + testCaseExecution = em.merge(testCaseExecution); + } + VmUser reviewer = executionStep.getReviewer(); + if (reviewer != null) { + reviewer.getExecutionStepList().remove(executionStep); + reviewer = em.merge(reviewer); + } + History stepHistory = executionStep.getStepHistory(); + if (stepHistory != null) { + stepHistory.getExecutionStepList().remove(executionStep); + stepHistory = em.merge(stepHistory); + } + List historyList = executionStep.getHistoryList(); + for (History historyListHistory : historyList) { + historyListHistory.getExecutionStepList().remove(executionStep); + historyListHistory = em.merge(historyListHistory); + } + em.remove(executionStep); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findExecutionStepEntities() { + return findExecutionStepEntities(true, -1, -1); + } + + public List findExecutionStepEntities(int maxResults, int firstResult) { + return findExecutionStepEntities(false, maxResults, firstResult); + } + + private List findExecutionStepEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(ExecutionStep.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public ExecutionStep findExecutionStep(ExecutionStepPK id) { + EntityManager em = getEntityManager(); + try { + return em.find(ExecutionStep.class, id); + } + finally { + em.close(); + } + } + + public int getExecutionStepCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(ExecutionStep.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/FailureModeJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/FailureModeJpaController.java index 43ab07c4..7298bf76 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/FailureModeJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/FailureModeJpaController.java @@ -13,186 +13,186 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.FailureMode; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.RiskItem; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class FailureModeJpaController implements Serializable { - - public FailureModeJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(FailureMode failureMode) { - if (failureMode.getRiskItemList() == null) { - failureMode.setRiskItemList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedRiskItemList = new ArrayList(); - for (RiskItem riskItemListRiskItemToAttach : failureMode.getRiskItemList()) { - riskItemListRiskItemToAttach = em.getReference(riskItemListRiskItemToAttach.getClass(), riskItemListRiskItemToAttach.getRiskItemPK()); - attachedRiskItemList.add(riskItemListRiskItemToAttach); - } - failureMode.setRiskItemList(attachedRiskItemList); - em.persist(failureMode); - for (RiskItem riskItemListRiskItem : failureMode.getRiskItemList()) { - riskItemListRiskItem.getFailureModeList().add(failureMode); - riskItemListRiskItem = em.merge(riskItemListRiskItem); - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(FailureMode failureMode) throws NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - FailureMode persistentFailureMode = em.find(FailureMode.class, failureMode.getId()); - List riskItemListOld = persistentFailureMode.getRiskItemList(); - List riskItemListNew = failureMode.getRiskItemList(); - List attachedRiskItemListNew = new ArrayList(); - for (RiskItem riskItemListNewRiskItemToAttach : riskItemListNew) { - riskItemListNewRiskItemToAttach = em.getReference(riskItemListNewRiskItemToAttach.getClass(), riskItemListNewRiskItemToAttach.getRiskItemPK()); - attachedRiskItemListNew.add(riskItemListNewRiskItemToAttach); - } - riskItemListNew = attachedRiskItemListNew; - failureMode.setRiskItemList(riskItemListNew); - failureMode = em.merge(failureMode); - for (RiskItem riskItemListOldRiskItem : riskItemListOld) { - if (!riskItemListNew.contains(riskItemListOldRiskItem)) { - riskItemListOldRiskItem.getFailureModeList().remove(failureMode); - riskItemListOldRiskItem = em.merge(riskItemListOldRiskItem); - } - } - for (RiskItem riskItemListNewRiskItem : riskItemListNew) { - if (!riskItemListOld.contains(riskItemListNewRiskItem)) { - riskItemListNewRiskItem.getFailureModeList().add(failureMode); - riskItemListNewRiskItem = em.merge(riskItemListNewRiskItem); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = failureMode.getId(); - if (findFailureMode(id) == null) { - throw new NonexistentEntityException("The failureMode with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - FailureMode failureMode; - try { - failureMode = em.getReference(FailureMode.class, id); - failureMode.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The failureMode with id " + id + " no longer exists.", enfe); - } - List riskItemList = failureMode.getRiskItemList(); - for (RiskItem riskItemListRiskItem : riskItemList) { - riskItemListRiskItem.getFailureModeList().remove(failureMode); - riskItemListRiskItem = em.merge(riskItemListRiskItem); - } - em.remove(failureMode); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findFailureModeEntities() { - return findFailureModeEntities(true, -1, -1); - } - - public List findFailureModeEntities(int maxResults, int firstResult) { - return findFailureModeEntities(false, maxResults, firstResult); - } - - private List findFailureModeEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(FailureMode.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public FailureMode findFailureMode(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(FailureMode.class, id); - } - finally { - em.close(); - } - } - - public int getFailureModeCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(FailureMode.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.FailureMode; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.RiskItem; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class FailureModeJpaController implements Serializable { + + public FailureModeJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(FailureMode failureMode) { + if (failureMode.getRiskItemList() == null) { + failureMode.setRiskItemList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedRiskItemList = new ArrayList<>(); + for (RiskItem riskItemListRiskItemToAttach : failureMode.getRiskItemList()) { + riskItemListRiskItemToAttach = em.getReference(riskItemListRiskItemToAttach.getClass(), riskItemListRiskItemToAttach.getRiskItemPK()); + attachedRiskItemList.add(riskItemListRiskItemToAttach); + } + failureMode.setRiskItemList(attachedRiskItemList); + em.persist(failureMode); + for (RiskItem riskItemListRiskItem : failureMode.getRiskItemList()) { + riskItemListRiskItem.getFailureModeList().add(failureMode); + riskItemListRiskItem = em.merge(riskItemListRiskItem); + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(FailureMode failureMode) throws NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + FailureMode persistentFailureMode = em.find(FailureMode.class, failureMode.getId()); + List riskItemListOld = persistentFailureMode.getRiskItemList(); + List riskItemListNew = failureMode.getRiskItemList(); + List attachedRiskItemListNew = new ArrayList<>(); + for (RiskItem riskItemListNewRiskItemToAttach : riskItemListNew) { + riskItemListNewRiskItemToAttach = em.getReference(riskItemListNewRiskItemToAttach.getClass(), riskItemListNewRiskItemToAttach.getRiskItemPK()); + attachedRiskItemListNew.add(riskItemListNewRiskItemToAttach); + } + riskItemListNew = attachedRiskItemListNew; + failureMode.setRiskItemList(riskItemListNew); + failureMode = em.merge(failureMode); + for (RiskItem riskItemListOldRiskItem : riskItemListOld) { + if (!riskItemListNew.contains(riskItemListOldRiskItem)) { + riskItemListOldRiskItem.getFailureModeList().remove(failureMode); + riskItemListOldRiskItem = em.merge(riskItemListOldRiskItem); + } + } + for (RiskItem riskItemListNewRiskItem : riskItemListNew) { + if (!riskItemListOld.contains(riskItemListNewRiskItem)) { + riskItemListNewRiskItem.getFailureModeList().add(failureMode); + riskItemListNewRiskItem = em.merge(riskItemListNewRiskItem); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = failureMode.getId(); + if (findFailureMode(id) == null) { + throw new NonexistentEntityException("The failureMode with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + FailureMode failureMode; + try { + failureMode = em.getReference(FailureMode.class, id); + failureMode.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The failureMode with id " + id + " no longer exists.", enfe); + } + List riskItemList = failureMode.getRiskItemList(); + for (RiskItem riskItemListRiskItem : riskItemList) { + riskItemListRiskItem.getFailureModeList().remove(failureMode); + riskItemListRiskItem = em.merge(riskItemListRiskItem); + } + em.remove(failureMode); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findFailureModeEntities() { + return findFailureModeEntities(true, -1, -1); + } + + public List findFailureModeEntities(int maxResults, int firstResult) { + return findFailureModeEntities(false, maxResults, firstResult); + } + + private List findFailureModeEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(FailureMode.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public FailureMode findFailureMode(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(FailureMode.class, id); + } + finally { + em.close(); + } + } + + public int getFailureModeCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(FailureMode.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/FieldTypeJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/FieldTypeJpaController.java index 899ef9b7..11f5995a 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/FieldTypeJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/FieldTypeJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.FieldType; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.HistoryField; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class FieldTypeJpaController implements Serializable { - - public FieldTypeJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(FieldType fieldType) { - if (fieldType.getHistoryFieldList() == null) { - fieldType.setHistoryFieldList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedHistoryFieldList = new ArrayList(); - for (HistoryField historyFieldListHistoryFieldToAttach : fieldType.getHistoryFieldList()) { - historyFieldListHistoryFieldToAttach = em.getReference(historyFieldListHistoryFieldToAttach.getClass(), historyFieldListHistoryFieldToAttach.getHistoryFieldPK()); - attachedHistoryFieldList.add(historyFieldListHistoryFieldToAttach); - } - fieldType.setHistoryFieldList(attachedHistoryFieldList); - em.persist(fieldType); - for (HistoryField historyFieldListHistoryField : fieldType.getHistoryFieldList()) { - FieldType oldFieldTypeOfHistoryFieldListHistoryField = historyFieldListHistoryField.getFieldType(); - historyFieldListHistoryField.setFieldType(fieldType); - historyFieldListHistoryField = em.merge(historyFieldListHistoryField); - if (oldFieldTypeOfHistoryFieldListHistoryField != null) { - oldFieldTypeOfHistoryFieldListHistoryField.getHistoryFieldList().remove(historyFieldListHistoryField); - oldFieldTypeOfHistoryFieldListHistoryField = em.merge(oldFieldTypeOfHistoryFieldListHistoryField); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(FieldType fieldType) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - FieldType persistentFieldType = em.find(FieldType.class, fieldType.getId()); - List historyFieldListOld = persistentFieldType.getHistoryFieldList(); - List historyFieldListNew = fieldType.getHistoryFieldList(); - List illegalOrphanMessages = null; - for (HistoryField historyFieldListOldHistoryField : historyFieldListOld) { - if (!historyFieldListNew.contains(historyFieldListOldHistoryField)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain HistoryField " + historyFieldListOldHistoryField + " since its fieldType field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedHistoryFieldListNew = new ArrayList(); - for (HistoryField historyFieldListNewHistoryFieldToAttach : historyFieldListNew) { - historyFieldListNewHistoryFieldToAttach = em.getReference(historyFieldListNewHistoryFieldToAttach.getClass(), historyFieldListNewHistoryFieldToAttach.getHistoryFieldPK()); - attachedHistoryFieldListNew.add(historyFieldListNewHistoryFieldToAttach); - } - historyFieldListNew = attachedHistoryFieldListNew; - fieldType.setHistoryFieldList(historyFieldListNew); - fieldType = em.merge(fieldType); - for (HistoryField historyFieldListNewHistoryField : historyFieldListNew) { - if (!historyFieldListOld.contains(historyFieldListNewHistoryField)) { - FieldType oldFieldTypeOfHistoryFieldListNewHistoryField = historyFieldListNewHistoryField.getFieldType(); - historyFieldListNewHistoryField.setFieldType(fieldType); - historyFieldListNewHistoryField = em.merge(historyFieldListNewHistoryField); - if (oldFieldTypeOfHistoryFieldListNewHistoryField != null && !oldFieldTypeOfHistoryFieldListNewHistoryField.equals(fieldType)) { - oldFieldTypeOfHistoryFieldListNewHistoryField.getHistoryFieldList().remove(historyFieldListNewHistoryField); - oldFieldTypeOfHistoryFieldListNewHistoryField = em.merge(oldFieldTypeOfHistoryFieldListNewHistoryField); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = fieldType.getId(); - if (findFieldType(id) == null) { - throw new NonexistentEntityException("The fieldType with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - FieldType fieldType; - try { - fieldType = em.getReference(FieldType.class, id); - fieldType.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The fieldType with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List historyFieldListOrphanCheck = fieldType.getHistoryFieldList(); - for (HistoryField historyFieldListOrphanCheckHistoryField : historyFieldListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This FieldType (" + fieldType + ") cannot be destroyed since the HistoryField " + historyFieldListOrphanCheckHistoryField + " in its historyFieldList field has a non-nullable fieldType field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(fieldType); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findFieldTypeEntities() { - return findFieldTypeEntities(true, -1, -1); - } - - public List findFieldTypeEntities(int maxResults, int firstResult) { - return findFieldTypeEntities(false, maxResults, firstResult); - } - - private List findFieldTypeEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(FieldType.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public FieldType findFieldType(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(FieldType.class, id); - } - finally { - em.close(); - } - } - - public int getFieldTypeCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(FieldType.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.FieldType; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.HistoryField; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class FieldTypeJpaController implements Serializable { + + public FieldTypeJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(FieldType fieldType) { + if (fieldType.getHistoryFieldList() == null) { + fieldType.setHistoryFieldList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedHistoryFieldList = new ArrayList<>(); + for (HistoryField historyFieldListHistoryFieldToAttach : fieldType.getHistoryFieldList()) { + historyFieldListHistoryFieldToAttach = em.getReference(historyFieldListHistoryFieldToAttach.getClass(), historyFieldListHistoryFieldToAttach.getHistoryFieldPK()); + attachedHistoryFieldList.add(historyFieldListHistoryFieldToAttach); + } + fieldType.setHistoryFieldList(attachedHistoryFieldList); + em.persist(fieldType); + for (HistoryField historyFieldListHistoryField : fieldType.getHistoryFieldList()) { + FieldType oldFieldTypeOfHistoryFieldListHistoryField = historyFieldListHistoryField.getFieldType(); + historyFieldListHistoryField.setFieldType(fieldType); + historyFieldListHistoryField = em.merge(historyFieldListHistoryField); + if (oldFieldTypeOfHistoryFieldListHistoryField != null) { + oldFieldTypeOfHistoryFieldListHistoryField.getHistoryFieldList().remove(historyFieldListHistoryField); + oldFieldTypeOfHistoryFieldListHistoryField = em.merge(oldFieldTypeOfHistoryFieldListHistoryField); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(FieldType fieldType) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + FieldType persistentFieldType = em.find(FieldType.class, fieldType.getId()); + List historyFieldListOld = persistentFieldType.getHistoryFieldList(); + List historyFieldListNew = fieldType.getHistoryFieldList(); + List illegalOrphanMessages = null; + for (HistoryField historyFieldListOldHistoryField : historyFieldListOld) { + if (!historyFieldListNew.contains(historyFieldListOldHistoryField)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain HistoryField " + historyFieldListOldHistoryField + " since its fieldType field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedHistoryFieldListNew = new ArrayList<>(); + for (HistoryField historyFieldListNewHistoryFieldToAttach : historyFieldListNew) { + historyFieldListNewHistoryFieldToAttach = em.getReference(historyFieldListNewHistoryFieldToAttach.getClass(), historyFieldListNewHistoryFieldToAttach.getHistoryFieldPK()); + attachedHistoryFieldListNew.add(historyFieldListNewHistoryFieldToAttach); + } + historyFieldListNew = attachedHistoryFieldListNew; + fieldType.setHistoryFieldList(historyFieldListNew); + fieldType = em.merge(fieldType); + for (HistoryField historyFieldListNewHistoryField : historyFieldListNew) { + if (!historyFieldListOld.contains(historyFieldListNewHistoryField)) { + FieldType oldFieldTypeOfHistoryFieldListNewHistoryField = historyFieldListNewHistoryField.getFieldType(); + historyFieldListNewHistoryField.setFieldType(fieldType); + historyFieldListNewHistoryField = em.merge(historyFieldListNewHistoryField); + if (oldFieldTypeOfHistoryFieldListNewHistoryField != null && !oldFieldTypeOfHistoryFieldListNewHistoryField.equals(fieldType)) { + oldFieldTypeOfHistoryFieldListNewHistoryField.getHistoryFieldList().remove(historyFieldListNewHistoryField); + oldFieldTypeOfHistoryFieldListNewHistoryField = em.merge(oldFieldTypeOfHistoryFieldListNewHistoryField); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = fieldType.getId(); + if (findFieldType(id) == null) { + throw new NonexistentEntityException("The fieldType with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + FieldType fieldType; + try { + fieldType = em.getReference(FieldType.class, id); + fieldType.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The fieldType with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List historyFieldListOrphanCheck = fieldType.getHistoryFieldList(); + for (HistoryField historyFieldListOrphanCheckHistoryField : historyFieldListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This FieldType (" + fieldType + ") cannot be destroyed since the HistoryField " + historyFieldListOrphanCheckHistoryField + " in its historyFieldList field has a non-nullable fieldType field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(fieldType); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findFieldTypeEntities() { + return findFieldTypeEntities(true, -1, -1); + } + + public List findFieldTypeEntities(int maxResults, int firstResult) { + return findFieldTypeEntities(false, maxResults, firstResult); + } + + private List findFieldTypeEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(FieldType.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public FieldType findFieldType(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(FieldType.class, id); + } + finally { + em.close(); + } + } + + public int getFieldTypeCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(FieldType.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/FmeaJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/FmeaJpaController.java index 69733618..882f8859 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/FmeaJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/FmeaJpaController.java @@ -13,326 +13,326 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Fmea; -import com.validation.manager.core.db.RiskCategory; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.RiskItem; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class FmeaJpaController implements Serializable { - - public FmeaJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(Fmea fmea) { - if (fmea.getRiskCategoryList() == null) { - fmea.setRiskCategoryList(new ArrayList()); - } - if (fmea.getRiskItemList() == null) { - fmea.setRiskItemList(new ArrayList()); - } - if (fmea.getFmeaList() == null) { - fmea.setFmeaList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Fmea parent = fmea.getParent(); - if (parent != null) { - parent = em.getReference(parent.getClass(), parent.getId()); - fmea.setParent(parent); - } - List attachedRiskCategoryList = new ArrayList(); - for (RiskCategory riskCategoryListRiskCategoryToAttach : fmea.getRiskCategoryList()) { - riskCategoryListRiskCategoryToAttach = em.getReference(riskCategoryListRiskCategoryToAttach.getClass(), riskCategoryListRiskCategoryToAttach.getId()); - attachedRiskCategoryList.add(riskCategoryListRiskCategoryToAttach); - } - fmea.setRiskCategoryList(attachedRiskCategoryList); - List attachedRiskItemList = new ArrayList(); - for (RiskItem riskItemListRiskItemToAttach : fmea.getRiskItemList()) { - riskItemListRiskItemToAttach = em.getReference(riskItemListRiskItemToAttach.getClass(), riskItemListRiskItemToAttach.getRiskItemPK()); - attachedRiskItemList.add(riskItemListRiskItemToAttach); - } - fmea.setRiskItemList(attachedRiskItemList); - List attachedFmeaList = new ArrayList(); - for (Fmea fmeaListFmeaToAttach : fmea.getFmeaList()) { - fmeaListFmeaToAttach = em.getReference(fmeaListFmeaToAttach.getClass(), fmeaListFmeaToAttach.getId()); - attachedFmeaList.add(fmeaListFmeaToAttach); - } - fmea.setFmeaList(attachedFmeaList); - em.persist(fmea); - if (parent != null) { - parent.getFmeaList().add(fmea); - parent = em.merge(parent); - } - for (RiskCategory riskCategoryListRiskCategory : fmea.getRiskCategoryList()) { - riskCategoryListRiskCategory.getFmeaList().add(fmea); - riskCategoryListRiskCategory = em.merge(riskCategoryListRiskCategory); - } - for (RiskItem riskItemListRiskItem : fmea.getRiskItemList()) { - Fmea oldFmeaOfRiskItemListRiskItem = riskItemListRiskItem.getFmea(); - riskItemListRiskItem.setFmea(fmea); - riskItemListRiskItem = em.merge(riskItemListRiskItem); - if (oldFmeaOfRiskItemListRiskItem != null) { - oldFmeaOfRiskItemListRiskItem.getRiskItemList().remove(riskItemListRiskItem); - oldFmeaOfRiskItemListRiskItem = em.merge(oldFmeaOfRiskItemListRiskItem); - } - } - for (Fmea fmeaListFmea : fmea.getFmeaList()) { - Fmea oldParentOfFmeaListFmea = fmeaListFmea.getParent(); - fmeaListFmea.setParent(fmea); - fmeaListFmea = em.merge(fmeaListFmea); - if (oldParentOfFmeaListFmea != null) { - oldParentOfFmeaListFmea.getFmeaList().remove(fmeaListFmea); - oldParentOfFmeaListFmea = em.merge(oldParentOfFmeaListFmea); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(Fmea fmea) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Fmea persistentFmea = em.find(Fmea.class, fmea.getId()); - Fmea parentOld = persistentFmea.getParent(); - Fmea parentNew = fmea.getParent(); - List riskCategoryListOld = persistentFmea.getRiskCategoryList(); - List riskCategoryListNew = fmea.getRiskCategoryList(); - List riskItemListOld = persistentFmea.getRiskItemList(); - List riskItemListNew = fmea.getRiskItemList(); - List fmeaListOld = persistentFmea.getFmeaList(); - List fmeaListNew = fmea.getFmeaList(); - List illegalOrphanMessages = null; - for (RiskItem riskItemListOldRiskItem : riskItemListOld) { - if (!riskItemListNew.contains(riskItemListOldRiskItem)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RiskItem " + riskItemListOldRiskItem + " since its fmea field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (parentNew != null) { - parentNew = em.getReference(parentNew.getClass(), parentNew.getId()); - fmea.setParent(parentNew); - } - List attachedRiskCategoryListNew = new ArrayList(); - for (RiskCategory riskCategoryListNewRiskCategoryToAttach : riskCategoryListNew) { - riskCategoryListNewRiskCategoryToAttach = em.getReference(riskCategoryListNewRiskCategoryToAttach.getClass(), riskCategoryListNewRiskCategoryToAttach.getId()); - attachedRiskCategoryListNew.add(riskCategoryListNewRiskCategoryToAttach); - } - riskCategoryListNew = attachedRiskCategoryListNew; - fmea.setRiskCategoryList(riskCategoryListNew); - List attachedRiskItemListNew = new ArrayList(); - for (RiskItem riskItemListNewRiskItemToAttach : riskItemListNew) { - riskItemListNewRiskItemToAttach = em.getReference(riskItemListNewRiskItemToAttach.getClass(), riskItemListNewRiskItemToAttach.getRiskItemPK()); - attachedRiskItemListNew.add(riskItemListNewRiskItemToAttach); - } - riskItemListNew = attachedRiskItemListNew; - fmea.setRiskItemList(riskItemListNew); - List attachedFmeaListNew = new ArrayList(); - for (Fmea fmeaListNewFmeaToAttach : fmeaListNew) { - fmeaListNewFmeaToAttach = em.getReference(fmeaListNewFmeaToAttach.getClass(), fmeaListNewFmeaToAttach.getId()); - attachedFmeaListNew.add(fmeaListNewFmeaToAttach); - } - fmeaListNew = attachedFmeaListNew; - fmea.setFmeaList(fmeaListNew); - fmea = em.merge(fmea); - if (parentOld != null && !parentOld.equals(parentNew)) { - parentOld.getFmeaList().remove(fmea); - parentOld = em.merge(parentOld); - } - if (parentNew != null && !parentNew.equals(parentOld)) { - parentNew.getFmeaList().add(fmea); - parentNew = em.merge(parentNew); - } - for (RiskCategory riskCategoryListOldRiskCategory : riskCategoryListOld) { - if (!riskCategoryListNew.contains(riskCategoryListOldRiskCategory)) { - riskCategoryListOldRiskCategory.getFmeaList().remove(fmea); - riskCategoryListOldRiskCategory = em.merge(riskCategoryListOldRiskCategory); - } - } - for (RiskCategory riskCategoryListNewRiskCategory : riskCategoryListNew) { - if (!riskCategoryListOld.contains(riskCategoryListNewRiskCategory)) { - riskCategoryListNewRiskCategory.getFmeaList().add(fmea); - riskCategoryListNewRiskCategory = em.merge(riskCategoryListNewRiskCategory); - } - } - for (RiskItem riskItemListNewRiskItem : riskItemListNew) { - if (!riskItemListOld.contains(riskItemListNewRiskItem)) { - Fmea oldFmeaOfRiskItemListNewRiskItem = riskItemListNewRiskItem.getFmea(); - riskItemListNewRiskItem.setFmea(fmea); - riskItemListNewRiskItem = em.merge(riskItemListNewRiskItem); - if (oldFmeaOfRiskItemListNewRiskItem != null && !oldFmeaOfRiskItemListNewRiskItem.equals(fmea)) { - oldFmeaOfRiskItemListNewRiskItem.getRiskItemList().remove(riskItemListNewRiskItem); - oldFmeaOfRiskItemListNewRiskItem = em.merge(oldFmeaOfRiskItemListNewRiskItem); - } - } - } - for (Fmea fmeaListOldFmea : fmeaListOld) { - if (!fmeaListNew.contains(fmeaListOldFmea)) { - fmeaListOldFmea.setParent(null); - fmeaListOldFmea = em.merge(fmeaListOldFmea); - } - } - for (Fmea fmeaListNewFmea : fmeaListNew) { - if (!fmeaListOld.contains(fmeaListNewFmea)) { - Fmea oldParentOfFmeaListNewFmea = fmeaListNewFmea.getParent(); - fmeaListNewFmea.setParent(fmea); - fmeaListNewFmea = em.merge(fmeaListNewFmea); - if (oldParentOfFmeaListNewFmea != null && !oldParentOfFmeaListNewFmea.equals(fmea)) { - oldParentOfFmeaListNewFmea.getFmeaList().remove(fmeaListNewFmea); - oldParentOfFmeaListNewFmea = em.merge(oldParentOfFmeaListNewFmea); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = fmea.getId(); - if (findFmea(id) == null) { - throw new NonexistentEntityException("The fmea with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Fmea fmea; - try { - fmea = em.getReference(Fmea.class, id); - fmea.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The fmea with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List riskItemListOrphanCheck = fmea.getRiskItemList(); - for (RiskItem riskItemListOrphanCheckRiskItem : riskItemListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Fmea (" + fmea + ") cannot be destroyed since the RiskItem " + riskItemListOrphanCheckRiskItem + " in its riskItemList field has a non-nullable fmea field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - Fmea parent = fmea.getParent(); - if (parent != null) { - parent.getFmeaList().remove(fmea); - parent = em.merge(parent); - } - List riskCategoryList = fmea.getRiskCategoryList(); - for (RiskCategory riskCategoryListRiskCategory : riskCategoryList) { - riskCategoryListRiskCategory.getFmeaList().remove(fmea); - riskCategoryListRiskCategory = em.merge(riskCategoryListRiskCategory); - } - List fmeaList = fmea.getFmeaList(); - for (Fmea fmeaListFmea : fmeaList) { - fmeaListFmea.setParent(null); - fmeaListFmea = em.merge(fmeaListFmea); - } - em.remove(fmea); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findFmeaEntities() { - return findFmeaEntities(true, -1, -1); - } - - public List findFmeaEntities(int maxResults, int firstResult) { - return findFmeaEntities(false, maxResults, firstResult); - } - - private List findFmeaEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(Fmea.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public Fmea findFmea(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(Fmea.class, id); - } - finally { - em.close(); - } - } - - public int getFmeaCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(Fmea.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Fmea; +import com.validation.manager.core.db.RiskCategory; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.RiskItem; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class FmeaJpaController implements Serializable { + + public FmeaJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(Fmea fmea) { + if (fmea.getRiskCategoryList() == null) { + fmea.setRiskCategoryList(new ArrayList<>()); + } + if (fmea.getRiskItemList() == null) { + fmea.setRiskItemList(new ArrayList<>()); + } + if (fmea.getFmeaList() == null) { + fmea.setFmeaList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Fmea parent = fmea.getParent(); + if (parent != null) { + parent = em.getReference(parent.getClass(), parent.getId()); + fmea.setParent(parent); + } + List attachedRiskCategoryList = new ArrayList<>(); + for (RiskCategory riskCategoryListRiskCategoryToAttach : fmea.getRiskCategoryList()) { + riskCategoryListRiskCategoryToAttach = em.getReference(riskCategoryListRiskCategoryToAttach.getClass(), riskCategoryListRiskCategoryToAttach.getId()); + attachedRiskCategoryList.add(riskCategoryListRiskCategoryToAttach); + } + fmea.setRiskCategoryList(attachedRiskCategoryList); + List attachedRiskItemList = new ArrayList<>(); + for (RiskItem riskItemListRiskItemToAttach : fmea.getRiskItemList()) { + riskItemListRiskItemToAttach = em.getReference(riskItemListRiskItemToAttach.getClass(), riskItemListRiskItemToAttach.getRiskItemPK()); + attachedRiskItemList.add(riskItemListRiskItemToAttach); + } + fmea.setRiskItemList(attachedRiskItemList); + List attachedFmeaList = new ArrayList<>(); + for (Fmea fmeaListFmeaToAttach : fmea.getFmeaList()) { + fmeaListFmeaToAttach = em.getReference(fmeaListFmeaToAttach.getClass(), fmeaListFmeaToAttach.getId()); + attachedFmeaList.add(fmeaListFmeaToAttach); + } + fmea.setFmeaList(attachedFmeaList); + em.persist(fmea); + if (parent != null) { + parent.getFmeaList().add(fmea); + parent = em.merge(parent); + } + for (RiskCategory riskCategoryListRiskCategory : fmea.getRiskCategoryList()) { + riskCategoryListRiskCategory.getFmeaList().add(fmea); + riskCategoryListRiskCategory = em.merge(riskCategoryListRiskCategory); + } + for (RiskItem riskItemListRiskItem : fmea.getRiskItemList()) { + Fmea oldFmeaOfRiskItemListRiskItem = riskItemListRiskItem.getFmea(); + riskItemListRiskItem.setFmea(fmea); + riskItemListRiskItem = em.merge(riskItemListRiskItem); + if (oldFmeaOfRiskItemListRiskItem != null) { + oldFmeaOfRiskItemListRiskItem.getRiskItemList().remove(riskItemListRiskItem); + oldFmeaOfRiskItemListRiskItem = em.merge(oldFmeaOfRiskItemListRiskItem); + } + } + for (Fmea fmeaListFmea : fmea.getFmeaList()) { + Fmea oldParentOfFmeaListFmea = fmeaListFmea.getParent(); + fmeaListFmea.setParent(fmea); + fmeaListFmea = em.merge(fmeaListFmea); + if (oldParentOfFmeaListFmea != null) { + oldParentOfFmeaListFmea.getFmeaList().remove(fmeaListFmea); + oldParentOfFmeaListFmea = em.merge(oldParentOfFmeaListFmea); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(Fmea fmea) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Fmea persistentFmea = em.find(Fmea.class, fmea.getId()); + Fmea parentOld = persistentFmea.getParent(); + Fmea parentNew = fmea.getParent(); + List riskCategoryListOld = persistentFmea.getRiskCategoryList(); + List riskCategoryListNew = fmea.getRiskCategoryList(); + List riskItemListOld = persistentFmea.getRiskItemList(); + List riskItemListNew = fmea.getRiskItemList(); + List fmeaListOld = persistentFmea.getFmeaList(); + List fmeaListNew = fmea.getFmeaList(); + List illegalOrphanMessages = null; + for (RiskItem riskItemListOldRiskItem : riskItemListOld) { + if (!riskItemListNew.contains(riskItemListOldRiskItem)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RiskItem " + riskItemListOldRiskItem + " since its fmea field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (parentNew != null) { + parentNew = em.getReference(parentNew.getClass(), parentNew.getId()); + fmea.setParent(parentNew); + } + List attachedRiskCategoryListNew = new ArrayList<>(); + for (RiskCategory riskCategoryListNewRiskCategoryToAttach : riskCategoryListNew) { + riskCategoryListNewRiskCategoryToAttach = em.getReference(riskCategoryListNewRiskCategoryToAttach.getClass(), riskCategoryListNewRiskCategoryToAttach.getId()); + attachedRiskCategoryListNew.add(riskCategoryListNewRiskCategoryToAttach); + } + riskCategoryListNew = attachedRiskCategoryListNew; + fmea.setRiskCategoryList(riskCategoryListNew); + List attachedRiskItemListNew = new ArrayList<>(); + for (RiskItem riskItemListNewRiskItemToAttach : riskItemListNew) { + riskItemListNewRiskItemToAttach = em.getReference(riskItemListNewRiskItemToAttach.getClass(), riskItemListNewRiskItemToAttach.getRiskItemPK()); + attachedRiskItemListNew.add(riskItemListNewRiskItemToAttach); + } + riskItemListNew = attachedRiskItemListNew; + fmea.setRiskItemList(riskItemListNew); + List attachedFmeaListNew = new ArrayList<>(); + for (Fmea fmeaListNewFmeaToAttach : fmeaListNew) { + fmeaListNewFmeaToAttach = em.getReference(fmeaListNewFmeaToAttach.getClass(), fmeaListNewFmeaToAttach.getId()); + attachedFmeaListNew.add(fmeaListNewFmeaToAttach); + } + fmeaListNew = attachedFmeaListNew; + fmea.setFmeaList(fmeaListNew); + fmea = em.merge(fmea); + if (parentOld != null && !parentOld.equals(parentNew)) { + parentOld.getFmeaList().remove(fmea); + parentOld = em.merge(parentOld); + } + if (parentNew != null && !parentNew.equals(parentOld)) { + parentNew.getFmeaList().add(fmea); + parentNew = em.merge(parentNew); + } + for (RiskCategory riskCategoryListOldRiskCategory : riskCategoryListOld) { + if (!riskCategoryListNew.contains(riskCategoryListOldRiskCategory)) { + riskCategoryListOldRiskCategory.getFmeaList().remove(fmea); + riskCategoryListOldRiskCategory = em.merge(riskCategoryListOldRiskCategory); + } + } + for (RiskCategory riskCategoryListNewRiskCategory : riskCategoryListNew) { + if (!riskCategoryListOld.contains(riskCategoryListNewRiskCategory)) { + riskCategoryListNewRiskCategory.getFmeaList().add(fmea); + riskCategoryListNewRiskCategory = em.merge(riskCategoryListNewRiskCategory); + } + } + for (RiskItem riskItemListNewRiskItem : riskItemListNew) { + if (!riskItemListOld.contains(riskItemListNewRiskItem)) { + Fmea oldFmeaOfRiskItemListNewRiskItem = riskItemListNewRiskItem.getFmea(); + riskItemListNewRiskItem.setFmea(fmea); + riskItemListNewRiskItem = em.merge(riskItemListNewRiskItem); + if (oldFmeaOfRiskItemListNewRiskItem != null && !oldFmeaOfRiskItemListNewRiskItem.equals(fmea)) { + oldFmeaOfRiskItemListNewRiskItem.getRiskItemList().remove(riskItemListNewRiskItem); + oldFmeaOfRiskItemListNewRiskItem = em.merge(oldFmeaOfRiskItemListNewRiskItem); + } + } + } + for (Fmea fmeaListOldFmea : fmeaListOld) { + if (!fmeaListNew.contains(fmeaListOldFmea)) { + fmeaListOldFmea.setParent(null); + fmeaListOldFmea = em.merge(fmeaListOldFmea); + } + } + for (Fmea fmeaListNewFmea : fmeaListNew) { + if (!fmeaListOld.contains(fmeaListNewFmea)) { + Fmea oldParentOfFmeaListNewFmea = fmeaListNewFmea.getParent(); + fmeaListNewFmea.setParent(fmea); + fmeaListNewFmea = em.merge(fmeaListNewFmea); + if (oldParentOfFmeaListNewFmea != null && !oldParentOfFmeaListNewFmea.equals(fmea)) { + oldParentOfFmeaListNewFmea.getFmeaList().remove(fmeaListNewFmea); + oldParentOfFmeaListNewFmea = em.merge(oldParentOfFmeaListNewFmea); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = fmea.getId(); + if (findFmea(id) == null) { + throw new NonexistentEntityException("The fmea with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Fmea fmea; + try { + fmea = em.getReference(Fmea.class, id); + fmea.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The fmea with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List riskItemListOrphanCheck = fmea.getRiskItemList(); + for (RiskItem riskItemListOrphanCheckRiskItem : riskItemListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Fmea (" + fmea + ") cannot be destroyed since the RiskItem " + riskItemListOrphanCheckRiskItem + " in its riskItemList field has a non-nullable fmea field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + Fmea parent = fmea.getParent(); + if (parent != null) { + parent.getFmeaList().remove(fmea); + parent = em.merge(parent); + } + List riskCategoryList = fmea.getRiskCategoryList(); + for (RiskCategory riskCategoryListRiskCategory : riskCategoryList) { + riskCategoryListRiskCategory.getFmeaList().remove(fmea); + riskCategoryListRiskCategory = em.merge(riskCategoryListRiskCategory); + } + List fmeaList = fmea.getFmeaList(); + for (Fmea fmeaListFmea : fmeaList) { + fmeaListFmea.setParent(null); + fmeaListFmea = em.merge(fmeaListFmea); + } + em.remove(fmea); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findFmeaEntities() { + return findFmeaEntities(true, -1, -1); + } + + public List findFmeaEntities(int maxResults, int firstResult) { + return findFmeaEntities(false, maxResults, firstResult); + } + + private List findFmeaEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(Fmea.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public Fmea findFmea(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(Fmea.class, id); + } + finally { + em.close(); + } + } + + public int getFmeaCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(Fmea.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/HazardJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/HazardJpaController.java index a0f03baf..0b28ec35 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/HazardJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/HazardJpaController.java @@ -13,186 +13,186 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.Hazard; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.RiskItem; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class HazardJpaController implements Serializable { - - public HazardJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(Hazard hazard) { - if (hazard.getRiskItemList() == null) { - hazard.setRiskItemList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedRiskItemList = new ArrayList(); - for (RiskItem riskItemListRiskItemToAttach : hazard.getRiskItemList()) { - riskItemListRiskItemToAttach = em.getReference(riskItemListRiskItemToAttach.getClass(), riskItemListRiskItemToAttach.getRiskItemPK()); - attachedRiskItemList.add(riskItemListRiskItemToAttach); - } - hazard.setRiskItemList(attachedRiskItemList); - em.persist(hazard); - for (RiskItem riskItemListRiskItem : hazard.getRiskItemList()) { - riskItemListRiskItem.getHazardList().add(hazard); - riskItemListRiskItem = em.merge(riskItemListRiskItem); - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(Hazard hazard) throws NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Hazard persistentHazard = em.find(Hazard.class, hazard.getId()); - List riskItemListOld = persistentHazard.getRiskItemList(); - List riskItemListNew = hazard.getRiskItemList(); - List attachedRiskItemListNew = new ArrayList(); - for (RiskItem riskItemListNewRiskItemToAttach : riskItemListNew) { - riskItemListNewRiskItemToAttach = em.getReference(riskItemListNewRiskItemToAttach.getClass(), riskItemListNewRiskItemToAttach.getRiskItemPK()); - attachedRiskItemListNew.add(riskItemListNewRiskItemToAttach); - } - riskItemListNew = attachedRiskItemListNew; - hazard.setRiskItemList(riskItemListNew); - hazard = em.merge(hazard); - for (RiskItem riskItemListOldRiskItem : riskItemListOld) { - if (!riskItemListNew.contains(riskItemListOldRiskItem)) { - riskItemListOldRiskItem.getHazardList().remove(hazard); - riskItemListOldRiskItem = em.merge(riskItemListOldRiskItem); - } - } - for (RiskItem riskItemListNewRiskItem : riskItemListNew) { - if (!riskItemListOld.contains(riskItemListNewRiskItem)) { - riskItemListNewRiskItem.getHazardList().add(hazard); - riskItemListNewRiskItem = em.merge(riskItemListNewRiskItem); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = hazard.getId(); - if (findHazard(id) == null) { - throw new NonexistentEntityException("The hazard with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Hazard hazard; - try { - hazard = em.getReference(Hazard.class, id); - hazard.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The hazard with id " + id + " no longer exists.", enfe); - } - List riskItemList = hazard.getRiskItemList(); - for (RiskItem riskItemListRiskItem : riskItemList) { - riskItemListRiskItem.getHazardList().remove(hazard); - riskItemListRiskItem = em.merge(riskItemListRiskItem); - } - em.remove(hazard); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findHazardEntities() { - return findHazardEntities(true, -1, -1); - } - - public List findHazardEntities(int maxResults, int firstResult) { - return findHazardEntities(false, maxResults, firstResult); - } - - private List findHazardEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(Hazard.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public Hazard findHazard(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(Hazard.class, id); - } - finally { - em.close(); - } - } - - public int getHazardCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(Hazard.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.Hazard; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.RiskItem; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class HazardJpaController implements Serializable { + + public HazardJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(Hazard hazard) { + if (hazard.getRiskItemList() == null) { + hazard.setRiskItemList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedRiskItemList = new ArrayList<>(); + for (RiskItem riskItemListRiskItemToAttach : hazard.getRiskItemList()) { + riskItemListRiskItemToAttach = em.getReference(riskItemListRiskItemToAttach.getClass(), riskItemListRiskItemToAttach.getRiskItemPK()); + attachedRiskItemList.add(riskItemListRiskItemToAttach); + } + hazard.setRiskItemList(attachedRiskItemList); + em.persist(hazard); + for (RiskItem riskItemListRiskItem : hazard.getRiskItemList()) { + riskItemListRiskItem.getHazardList().add(hazard); + riskItemListRiskItem = em.merge(riskItemListRiskItem); + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(Hazard hazard) throws NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Hazard persistentHazard = em.find(Hazard.class, hazard.getId()); + List riskItemListOld = persistentHazard.getRiskItemList(); + List riskItemListNew = hazard.getRiskItemList(); + List attachedRiskItemListNew = new ArrayList<>(); + for (RiskItem riskItemListNewRiskItemToAttach : riskItemListNew) { + riskItemListNewRiskItemToAttach = em.getReference(riskItemListNewRiskItemToAttach.getClass(), riskItemListNewRiskItemToAttach.getRiskItemPK()); + attachedRiskItemListNew.add(riskItemListNewRiskItemToAttach); + } + riskItemListNew = attachedRiskItemListNew; + hazard.setRiskItemList(riskItemListNew); + hazard = em.merge(hazard); + for (RiskItem riskItemListOldRiskItem : riskItemListOld) { + if (!riskItemListNew.contains(riskItemListOldRiskItem)) { + riskItemListOldRiskItem.getHazardList().remove(hazard); + riskItemListOldRiskItem = em.merge(riskItemListOldRiskItem); + } + } + for (RiskItem riskItemListNewRiskItem : riskItemListNew) { + if (!riskItemListOld.contains(riskItemListNewRiskItem)) { + riskItemListNewRiskItem.getHazardList().add(hazard); + riskItemListNewRiskItem = em.merge(riskItemListNewRiskItem); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = hazard.getId(); + if (findHazard(id) == null) { + throw new NonexistentEntityException("The hazard with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Hazard hazard; + try { + hazard = em.getReference(Hazard.class, id); + hazard.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The hazard with id " + id + " no longer exists.", enfe); + } + List riskItemList = hazard.getRiskItemList(); + for (RiskItem riskItemListRiskItem : riskItemList) { + riskItemListRiskItem.getHazardList().remove(hazard); + riskItemListRiskItem = em.merge(riskItemListRiskItem); + } + em.remove(hazard); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findHazardEntities() { + return findHazardEntities(true, -1, -1); + } + + public List findHazardEntities(int maxResults, int firstResult) { + return findHazardEntities(false, maxResults, firstResult); + } + + private List findHazardEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(Hazard.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public Hazard findHazard(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(Hazard.class, id); + } + finally { + em.close(); + } + } + + public int getHazardCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(Hazard.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/HistoryJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/HistoryJpaController.java index 8c3caa07..27ac154b 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/HistoryJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/HistoryJpaController.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,434 +13,462 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.Requirement; -import com.validation.manager.core.db.Project; -import com.validation.manager.core.db.Step; -import com.validation.manager.core.db.VmSetting; -import com.validation.manager.core.db.HistoryField; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.Baseline; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class HistoryJpaController implements Serializable { - - public HistoryJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(History history) { - if (history.getHistoryFieldList() == null) { - history.setHistoryFieldList(new ArrayList()); - } - if (history.getBaselineList() == null) { - history.setBaselineList(new ArrayList()); - } - if (history.getExecutionStepList() == null) { - history.setExecutionStepList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - VmUser modifierId = history.getModifierId(); - if (modifierId != null) { - modifierId = em.getReference(modifierId.getClass(), modifierId.getId()); - history.setModifierId(modifierId); - } - Requirement requirementId = history.getRequirementId(); - if (requirementId != null) { - requirementId = em.getReference(requirementId.getClass(), requirementId.getId()); - history.setRequirementId(requirementId); - } - Project projectId = history.getProjectId(); - if (projectId != null) { - projectId = em.getReference(projectId.getClass(), projectId.getId()); - history.setProjectId(projectId); - } - Step step = history.getStep(); - if (step != null) { - step = em.getReference(step.getClass(), step.getStepPK()); - history.setStep(step); - } - VmSetting vmSettingId = history.getVmSettingId(); - if (vmSettingId != null) { - vmSettingId = em.getReference(vmSettingId.getClass(), vmSettingId.getId()); - history.setVmSettingId(vmSettingId); - } - List attachedHistoryFieldList = new ArrayList(); - for (HistoryField historyFieldListHistoryFieldToAttach : history.getHistoryFieldList()) { - historyFieldListHistoryFieldToAttach = em.getReference(historyFieldListHistoryFieldToAttach.getClass(), historyFieldListHistoryFieldToAttach.getHistoryFieldPK()); - attachedHistoryFieldList.add(historyFieldListHistoryFieldToAttach); - } - history.setHistoryFieldList(attachedHistoryFieldList); - List attachedBaselineList = new ArrayList(); - for (Baseline baselineListBaselineToAttach : history.getBaselineList()) { - baselineListBaselineToAttach = em.getReference(baselineListBaselineToAttach.getClass(), baselineListBaselineToAttach.getId()); - attachedBaselineList.add(baselineListBaselineToAttach); - } - history.setBaselineList(attachedBaselineList); - List attachedExecutionStepList = new ArrayList(); - for (ExecutionStep executionStepListExecutionStepToAttach : history.getExecutionStepList()) { - executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepList.add(executionStepListExecutionStepToAttach); - } - history.setExecutionStepList(attachedExecutionStepList); - em.persist(history); - if (modifierId != null) { - modifierId.getHistoryModificationList().add(history); - modifierId = em.merge(modifierId); - } - if (requirementId != null) { - requirementId.getHistoryList().add(history); - requirementId = em.merge(requirementId); - } - if (projectId != null) { - projectId.getHistoryList().add(history); - projectId = em.merge(projectId); - } - if (step != null) { - step.getHistoryList().add(history); - step = em.merge(step); - } - if (vmSettingId != null) { - vmSettingId.getHistoryList().add(history); - vmSettingId = em.merge(vmSettingId); - } - for (HistoryField historyFieldListHistoryField : history.getHistoryFieldList()) { - History oldHistoryOfHistoryFieldListHistoryField = historyFieldListHistoryField.getHistory(); - historyFieldListHistoryField.setHistory(history); - historyFieldListHistoryField = em.merge(historyFieldListHistoryField); - if (oldHistoryOfHistoryFieldListHistoryField != null) { - oldHistoryOfHistoryFieldListHistoryField.getHistoryFieldList().remove(historyFieldListHistoryField); - oldHistoryOfHistoryFieldListHistoryField = em.merge(oldHistoryOfHistoryFieldListHistoryField); - } - } - for (Baseline baselineListBaseline : history.getBaselineList()) { - baselineListBaseline.getHistoryList().add(history); - baselineListBaseline = em.merge(baselineListBaseline); - } - for (ExecutionStep executionStepListExecutionStep : history.getExecutionStepList()) { - executionStepListExecutionStep.getHistoryList().add(history); - executionStepListExecutionStep = em.merge(executionStepListExecutionStep); - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(History history) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - History persistentHistory = em.find(History.class, history.getId()); - VmUser modifierIdOld = persistentHistory.getModifierId(); - VmUser modifierIdNew = history.getModifierId(); - Requirement requirementIdOld = persistentHistory.getRequirementId(); - Requirement requirementIdNew = history.getRequirementId(); - Project projectIdOld = persistentHistory.getProjectId(); - Project projectIdNew = history.getProjectId(); - Step stepOld = persistentHistory.getStep(); - Step stepNew = history.getStep(); - VmSetting vmSettingIdOld = persistentHistory.getVmSettingId(); - VmSetting vmSettingIdNew = history.getVmSettingId(); - List historyFieldListOld = persistentHistory.getHistoryFieldList(); - List historyFieldListNew = history.getHistoryFieldList(); - List baselineListOld = persistentHistory.getBaselineList(); - List baselineListNew = history.getBaselineList(); - List executionStepListOld = persistentHistory.getExecutionStepList(); - List executionStepListNew = history.getExecutionStepList(); - List illegalOrphanMessages = null; - for (HistoryField historyFieldListOldHistoryField : historyFieldListOld) { - if (!historyFieldListNew.contains(historyFieldListOldHistoryField)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain HistoryField " + historyFieldListOldHistoryField + " since its history field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (modifierIdNew != null) { - modifierIdNew = em.getReference(modifierIdNew.getClass(), modifierIdNew.getId()); - history.setModifierId(modifierIdNew); - } - if (requirementIdNew != null) { - requirementIdNew = em.getReference(requirementIdNew.getClass(), requirementIdNew.getId()); - history.setRequirementId(requirementIdNew); - } - if (projectIdNew != null) { - projectIdNew = em.getReference(projectIdNew.getClass(), projectIdNew.getId()); - history.setProjectId(projectIdNew); - } - if (stepNew != null) { - stepNew = em.getReference(stepNew.getClass(), stepNew.getStepPK()); - history.setStep(stepNew); - } - if (vmSettingIdNew != null) { - vmSettingIdNew = em.getReference(vmSettingIdNew.getClass(), vmSettingIdNew.getId()); - history.setVmSettingId(vmSettingIdNew); - } - List attachedHistoryFieldListNew = new ArrayList(); - for (HistoryField historyFieldListNewHistoryFieldToAttach : historyFieldListNew) { - historyFieldListNewHistoryFieldToAttach = em.getReference(historyFieldListNewHistoryFieldToAttach.getClass(), historyFieldListNewHistoryFieldToAttach.getHistoryFieldPK()); - attachedHistoryFieldListNew.add(historyFieldListNewHistoryFieldToAttach); - } - historyFieldListNew = attachedHistoryFieldListNew; - history.setHistoryFieldList(historyFieldListNew); - List attachedBaselineListNew = new ArrayList(); - for (Baseline baselineListNewBaselineToAttach : baselineListNew) { - baselineListNewBaselineToAttach = em.getReference(baselineListNewBaselineToAttach.getClass(), baselineListNewBaselineToAttach.getId()); - attachedBaselineListNew.add(baselineListNewBaselineToAttach); - } - baselineListNew = attachedBaselineListNew; - history.setBaselineList(baselineListNew); - List attachedExecutionStepListNew = new ArrayList(); - for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { - executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); - } - executionStepListNew = attachedExecutionStepListNew; - history.setExecutionStepList(executionStepListNew); - history = em.merge(history); - if (modifierIdOld != null && !modifierIdOld.equals(modifierIdNew)) { - modifierIdOld.getHistoryModificationList().remove(history); - modifierIdOld = em.merge(modifierIdOld); - } - if (modifierIdNew != null && !modifierIdNew.equals(modifierIdOld)) { - modifierIdNew.getHistoryModificationList().add(history); - modifierIdNew = em.merge(modifierIdNew); - } - if (requirementIdOld != null && !requirementIdOld.equals(requirementIdNew)) { - requirementIdOld.getHistoryList().remove(history); - requirementIdOld = em.merge(requirementIdOld); - } - if (requirementIdNew != null && !requirementIdNew.equals(requirementIdOld)) { - requirementIdNew.getHistoryList().add(history); - requirementIdNew = em.merge(requirementIdNew); - } - if (projectIdOld != null && !projectIdOld.equals(projectIdNew)) { - projectIdOld.getHistoryList().remove(history); - projectIdOld = em.merge(projectIdOld); - } - if (projectIdNew != null && !projectIdNew.equals(projectIdOld)) { - projectIdNew.getHistoryList().add(history); - projectIdNew = em.merge(projectIdNew); - } - if (stepOld != null && !stepOld.equals(stepNew)) { - stepOld.getHistoryList().remove(history); - stepOld = em.merge(stepOld); - } - if (stepNew != null && !stepNew.equals(stepOld)) { - stepNew.getHistoryList().add(history); - stepNew = em.merge(stepNew); - } - if (vmSettingIdOld != null && !vmSettingIdOld.equals(vmSettingIdNew)) { - vmSettingIdOld.getHistoryList().remove(history); - vmSettingIdOld = em.merge(vmSettingIdOld); - } - if (vmSettingIdNew != null && !vmSettingIdNew.equals(vmSettingIdOld)) { - vmSettingIdNew.getHistoryList().add(history); - vmSettingIdNew = em.merge(vmSettingIdNew); - } - for (HistoryField historyFieldListNewHistoryField : historyFieldListNew) { - if (!historyFieldListOld.contains(historyFieldListNewHistoryField)) { - History oldHistoryOfHistoryFieldListNewHistoryField = historyFieldListNewHistoryField.getHistory(); - historyFieldListNewHistoryField.setHistory(history); - historyFieldListNewHistoryField = em.merge(historyFieldListNewHistoryField); - if (oldHistoryOfHistoryFieldListNewHistoryField != null && !oldHistoryOfHistoryFieldListNewHistoryField.equals(history)) { - oldHistoryOfHistoryFieldListNewHistoryField.getHistoryFieldList().remove(historyFieldListNewHistoryField); - oldHistoryOfHistoryFieldListNewHistoryField = em.merge(oldHistoryOfHistoryFieldListNewHistoryField); - } - } - } - for (Baseline baselineListOldBaseline : baselineListOld) { - if (!baselineListNew.contains(baselineListOldBaseline)) { - baselineListOldBaseline.getHistoryList().remove(history); - baselineListOldBaseline = em.merge(baselineListOldBaseline); - } - } - for (Baseline baselineListNewBaseline : baselineListNew) { - if (!baselineListOld.contains(baselineListNewBaseline)) { - baselineListNewBaseline.getHistoryList().add(history); - baselineListNewBaseline = em.merge(baselineListNewBaseline); - } - } - for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { - if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { - executionStepListOldExecutionStep.getHistoryList().remove(history); - executionStepListOldExecutionStep = em.merge(executionStepListOldExecutionStep); - } - } - for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { - if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { - executionStepListNewExecutionStep.getHistoryList().add(history); - executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = history.getId(); - if (findHistory(id) == null) { - throw new NonexistentEntityException("The history with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - History history; - try { - history = em.getReference(History.class, id); - history.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The history with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List historyFieldListOrphanCheck = history.getHistoryFieldList(); - for (HistoryField historyFieldListOrphanCheckHistoryField : historyFieldListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This History (" + history + ") cannot be destroyed since the HistoryField " + historyFieldListOrphanCheckHistoryField + " in its historyFieldList field has a non-nullable history field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - VmUser modifierId = history.getModifierId(); - if (modifierId != null) { - modifierId.getHistoryModificationList().remove(history); - modifierId = em.merge(modifierId); - } - Requirement requirementId = history.getRequirementId(); - if (requirementId != null) { - requirementId.getHistoryList().remove(history); - requirementId = em.merge(requirementId); - } - Project projectId = history.getProjectId(); - if (projectId != null) { - projectId.getHistoryList().remove(history); - projectId = em.merge(projectId); - } - Step step = history.getStep(); - if (step != null) { - step.getHistoryList().remove(history); - step = em.merge(step); - } - VmSetting vmSettingId = history.getVmSettingId(); - if (vmSettingId != null) { - vmSettingId.getHistoryList().remove(history); - vmSettingId = em.merge(vmSettingId); - } - List baselineList = history.getBaselineList(); - for (Baseline baselineListBaseline : baselineList) { - baselineListBaseline.getHistoryList().remove(history); - baselineListBaseline = em.merge(baselineListBaseline); - } - List executionStepList = history.getExecutionStepList(); - for (ExecutionStep executionStepListExecutionStep : executionStepList) { - executionStepListExecutionStep.getHistoryList().remove(history); - executionStepListExecutionStep = em.merge(executionStepListExecutionStep); - } - em.remove(history); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findHistoryEntities() { - return findHistoryEntities(true, -1, -1); - } - - public List findHistoryEntities(int maxResults, int firstResult) { - return findHistoryEntities(false, maxResults, firstResult); - } - - private List findHistoryEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(History.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public History findHistory(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(History.class, id); - } - finally { - em.close(); - } - } - - public int getHistoryCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(History.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.Requirement; +import com.validation.manager.core.db.Project; +import com.validation.manager.core.db.Step; +import com.validation.manager.core.db.VmSetting; +import com.validation.manager.core.db.HistoryField; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.Baseline; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class HistoryJpaController implements Serializable { + + public HistoryJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(History history) { + if (history.getHistoryFieldList() == null) { + history.setHistoryFieldList(new ArrayList<>()); + } + if (history.getBaselineList() == null) { + history.setBaselineList(new ArrayList<>()); + } + if (history.getExecutionStepList() == null) { + history.setExecutionStepList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + VmUser modifierId = history.getModifierId(); + if (modifierId != null) { + modifierId = em.getReference(modifierId.getClass(), modifierId.getId()); + history.setModifierId(modifierId); + } + Requirement requirementId = history.getRequirementId(); + if (requirementId != null) { + requirementId = em.getReference(requirementId.getClass(), requirementId.getId()); + history.setRequirementId(requirementId); + } + Project projectId = history.getProjectId(); + if (projectId != null) { + projectId = em.getReference(projectId.getClass(), projectId.getId()); + history.setProjectId(projectId); + } + Step step = history.getStep(); + if (step != null) { + step = em.getReference(step.getClass(), step.getStepPK()); + history.setStep(step); + } + VmSetting vmSettingId = history.getVmSettingId(); + if (vmSettingId != null) { + vmSettingId = em.getReference(vmSettingId.getClass(), vmSettingId.getId()); + history.setVmSettingId(vmSettingId); + } + VmUser vmUserId = history.getVmUserId(); + if (vmUserId != null) { + vmUserId = em.getReference(vmUserId.getClass(), vmUserId.getId()); + history.setVmUserId(vmUserId); + } + List attachedHistoryFieldList = new ArrayList<>(); + for (HistoryField historyFieldListHistoryFieldToAttach : history.getHistoryFieldList()) { + historyFieldListHistoryFieldToAttach = em.getReference(historyFieldListHistoryFieldToAttach.getClass(), historyFieldListHistoryFieldToAttach.getHistoryFieldPK()); + attachedHistoryFieldList.add(historyFieldListHistoryFieldToAttach); + } + history.setHistoryFieldList(attachedHistoryFieldList); + List attachedBaselineList = new ArrayList<>(); + for (Baseline baselineListBaselineToAttach : history.getBaselineList()) { + baselineListBaselineToAttach = em.getReference(baselineListBaselineToAttach.getClass(), baselineListBaselineToAttach.getId()); + attachedBaselineList.add(baselineListBaselineToAttach); + } + history.setBaselineList(attachedBaselineList); + List attachedExecutionStepList = new ArrayList<>(); + for (ExecutionStep executionStepListExecutionStepToAttach : history.getExecutionStepList()) { + executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepList.add(executionStepListExecutionStepToAttach); + } + history.setExecutionStepList(attachedExecutionStepList); + em.persist(history); + if (modifierId != null) { + modifierId.getHistoryModificationList().add(history); + modifierId = em.merge(modifierId); + } + if (requirementId != null) { + requirementId.getHistoryList().add(history); + requirementId = em.merge(requirementId); + } + if (projectId != null) { + projectId.getHistoryList().add(history); + projectId = em.merge(projectId); + } + if (step != null) { + step.getHistoryList().add(history); + step = em.merge(step); + } + if (vmSettingId != null) { + vmSettingId.getHistoryList().add(history); + vmSettingId = em.merge(vmSettingId); + } + if (vmUserId != null) { + vmUserId.getHistoryModificationList().add(history); + vmUserId = em.merge(vmUserId); + } + for (HistoryField historyFieldListHistoryField : history.getHistoryFieldList()) { + History oldHistoryOfHistoryFieldListHistoryField = historyFieldListHistoryField.getHistory(); + historyFieldListHistoryField.setHistory(history); + historyFieldListHistoryField = em.merge(historyFieldListHistoryField); + if (oldHistoryOfHistoryFieldListHistoryField != null) { + oldHistoryOfHistoryFieldListHistoryField.getHistoryFieldList().remove(historyFieldListHistoryField); + oldHistoryOfHistoryFieldListHistoryField = em.merge(oldHistoryOfHistoryFieldListHistoryField); + } + } + for (Baseline baselineListBaseline : history.getBaselineList()) { + baselineListBaseline.getHistoryList().add(history); + baselineListBaseline = em.merge(baselineListBaseline); + } + for (ExecutionStep executionStepListExecutionStep : history.getExecutionStepList()) { + executionStepListExecutionStep.getHistoryList().add(history); + executionStepListExecutionStep = em.merge(executionStepListExecutionStep); + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(History history) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + History persistentHistory = em.find(History.class, history.getId()); + VmUser modifierIdOld = persistentHistory.getModifierId(); + VmUser modifierIdNew = history.getModifierId(); + Requirement requirementIdOld = persistentHistory.getRequirementId(); + Requirement requirementIdNew = history.getRequirementId(); + Project projectIdOld = persistentHistory.getProjectId(); + Project projectIdNew = history.getProjectId(); + Step stepOld = persistentHistory.getStep(); + Step stepNew = history.getStep(); + VmSetting vmSettingIdOld = persistentHistory.getVmSettingId(); + VmSetting vmSettingIdNew = history.getVmSettingId(); + VmUser vmUserIdOld = persistentHistory.getVmUserId(); + VmUser vmUserIdNew = history.getVmUserId(); + List historyFieldListOld = persistentHistory.getHistoryFieldList(); + List historyFieldListNew = history.getHistoryFieldList(); + List baselineListOld = persistentHistory.getBaselineList(); + List baselineListNew = history.getBaselineList(); + List executionStepListOld = persistentHistory.getExecutionStepList(); + List executionStepListNew = history.getExecutionStepList(); + List illegalOrphanMessages = null; + for (HistoryField historyFieldListOldHistoryField : historyFieldListOld) { + if (!historyFieldListNew.contains(historyFieldListOldHistoryField)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain HistoryField " + historyFieldListOldHistoryField + " since its history field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (modifierIdNew != null) { + modifierIdNew = em.getReference(modifierIdNew.getClass(), modifierIdNew.getId()); + history.setModifierId(modifierIdNew); + } + if (requirementIdNew != null) { + requirementIdNew = em.getReference(requirementIdNew.getClass(), requirementIdNew.getId()); + history.setRequirementId(requirementIdNew); + } + if (projectIdNew != null) { + projectIdNew = em.getReference(projectIdNew.getClass(), projectIdNew.getId()); + history.setProjectId(projectIdNew); + } + if (stepNew != null) { + stepNew = em.getReference(stepNew.getClass(), stepNew.getStepPK()); + history.setStep(stepNew); + } + if (vmSettingIdNew != null) { + vmSettingIdNew = em.getReference(vmSettingIdNew.getClass(), vmSettingIdNew.getId()); + history.setVmSettingId(vmSettingIdNew); + } + if (vmUserIdNew != null) { + vmUserIdNew = em.getReference(vmUserIdNew.getClass(), vmUserIdNew.getId()); + history.setVmUserId(vmUserIdNew); + } + List attachedHistoryFieldListNew = new ArrayList<>(); + for (HistoryField historyFieldListNewHistoryFieldToAttach : historyFieldListNew) { + historyFieldListNewHistoryFieldToAttach = em.getReference(historyFieldListNewHistoryFieldToAttach.getClass(), historyFieldListNewHistoryFieldToAttach.getHistoryFieldPK()); + attachedHistoryFieldListNew.add(historyFieldListNewHistoryFieldToAttach); + } + historyFieldListNew = attachedHistoryFieldListNew; + history.setHistoryFieldList(historyFieldListNew); + List attachedBaselineListNew = new ArrayList<>(); + for (Baseline baselineListNewBaselineToAttach : baselineListNew) { + baselineListNewBaselineToAttach = em.getReference(baselineListNewBaselineToAttach.getClass(), baselineListNewBaselineToAttach.getId()); + attachedBaselineListNew.add(baselineListNewBaselineToAttach); + } + baselineListNew = attachedBaselineListNew; + history.setBaselineList(baselineListNew); + List attachedExecutionStepListNew = new ArrayList<>(); + for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { + executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); + } + executionStepListNew = attachedExecutionStepListNew; + history.setExecutionStepList(executionStepListNew); + history = em.merge(history); + if (modifierIdOld != null && !modifierIdOld.equals(modifierIdNew)) { + modifierIdOld.getHistoryModificationList().remove(history); + modifierIdOld = em.merge(modifierIdOld); + } + if (modifierIdNew != null && !modifierIdNew.equals(modifierIdOld)) { + modifierIdNew.getHistoryModificationList().add(history); + modifierIdNew = em.merge(modifierIdNew); + } + if (requirementIdOld != null && !requirementIdOld.equals(requirementIdNew)) { + requirementIdOld.getHistoryList().remove(history); + requirementIdOld = em.merge(requirementIdOld); + } + if (requirementIdNew != null && !requirementIdNew.equals(requirementIdOld)) { + requirementIdNew.getHistoryList().add(history); + requirementIdNew = em.merge(requirementIdNew); + } + if (projectIdOld != null && !projectIdOld.equals(projectIdNew)) { + projectIdOld.getHistoryList().remove(history); + projectIdOld = em.merge(projectIdOld); + } + if (projectIdNew != null && !projectIdNew.equals(projectIdOld)) { + projectIdNew.getHistoryList().add(history); + projectIdNew = em.merge(projectIdNew); + } + if (stepOld != null && !stepOld.equals(stepNew)) { + stepOld.getHistoryList().remove(history); + stepOld = em.merge(stepOld); + } + if (stepNew != null && !stepNew.equals(stepOld)) { + stepNew.getHistoryList().add(history); + stepNew = em.merge(stepNew); + } + if (vmSettingIdOld != null && !vmSettingIdOld.equals(vmSettingIdNew)) { + vmSettingIdOld.getHistoryList().remove(history); + vmSettingIdOld = em.merge(vmSettingIdOld); + } + if (vmSettingIdNew != null && !vmSettingIdNew.equals(vmSettingIdOld)) { + vmSettingIdNew.getHistoryList().add(history); + vmSettingIdNew = em.merge(vmSettingIdNew); + } + if (vmUserIdOld != null && !vmUserIdOld.equals(vmUserIdNew)) { + vmUserIdOld.getHistoryModificationList().remove(history); + vmUserIdOld = em.merge(vmUserIdOld); + } + if (vmUserIdNew != null && !vmUserIdNew.equals(vmUserIdOld)) { + vmUserIdNew.getHistoryModificationList().add(history); + vmUserIdNew = em.merge(vmUserIdNew); + } + for (HistoryField historyFieldListNewHistoryField : historyFieldListNew) { + if (!historyFieldListOld.contains(historyFieldListNewHistoryField)) { + History oldHistoryOfHistoryFieldListNewHistoryField = historyFieldListNewHistoryField.getHistory(); + historyFieldListNewHistoryField.setHistory(history); + historyFieldListNewHistoryField = em.merge(historyFieldListNewHistoryField); + if (oldHistoryOfHistoryFieldListNewHistoryField != null && !oldHistoryOfHistoryFieldListNewHistoryField.equals(history)) { + oldHistoryOfHistoryFieldListNewHistoryField.getHistoryFieldList().remove(historyFieldListNewHistoryField); + oldHistoryOfHistoryFieldListNewHistoryField = em.merge(oldHistoryOfHistoryFieldListNewHistoryField); + } + } + } + for (Baseline baselineListOldBaseline : baselineListOld) { + if (!baselineListNew.contains(baselineListOldBaseline)) { + baselineListOldBaseline.getHistoryList().remove(history); + baselineListOldBaseline = em.merge(baselineListOldBaseline); + } + } + for (Baseline baselineListNewBaseline : baselineListNew) { + if (!baselineListOld.contains(baselineListNewBaseline)) { + baselineListNewBaseline.getHistoryList().add(history); + baselineListNewBaseline = em.merge(baselineListNewBaseline); + } + } + for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { + if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { + executionStepListOldExecutionStep.getHistoryList().remove(history); + executionStepListOldExecutionStep = em.merge(executionStepListOldExecutionStep); + } + } + for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { + if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { + executionStepListNewExecutionStep.getHistoryList().add(history); + executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = history.getId(); + if (findHistory(id) == null) { + throw new NonexistentEntityException("The history with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + History history; + try { + history = em.getReference(History.class, id); + history.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The history with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List historyFieldListOrphanCheck = history.getHistoryFieldList(); + for (HistoryField historyFieldListOrphanCheckHistoryField : historyFieldListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This History (" + history + ") cannot be destroyed since the HistoryField " + historyFieldListOrphanCheckHistoryField + " in its historyFieldList field has a non-nullable history field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + VmUser modifierId = history.getModifierId(); + if (modifierId != null) { + modifierId.getHistoryModificationList().remove(history); + modifierId = em.merge(modifierId); + } + Requirement requirementId = history.getRequirementId(); + if (requirementId != null) { + requirementId.getHistoryList().remove(history); + requirementId = em.merge(requirementId); + } + Project projectId = history.getProjectId(); + if (projectId != null) { + projectId.getHistoryList().remove(history); + projectId = em.merge(projectId); + } + Step step = history.getStep(); + if (step != null) { + step.getHistoryList().remove(history); + step = em.merge(step); + } + VmSetting vmSettingId = history.getVmSettingId(); + if (vmSettingId != null) { + vmSettingId.getHistoryList().remove(history); + vmSettingId = em.merge(vmSettingId); + } + VmUser vmUserId = history.getVmUserId(); + if (vmUserId != null) { + vmUserId.getHistoryModificationList().remove(history); + vmUserId = em.merge(vmUserId); + } + List baselineList = history.getBaselineList(); + for (Baseline baselineListBaseline : baselineList) { + baselineListBaseline.getHistoryList().remove(history); + baselineListBaseline = em.merge(baselineListBaseline); + } + List executionStepList = history.getExecutionStepList(); + for (ExecutionStep executionStepListExecutionStep : executionStepList) { + executionStepListExecutionStep.getHistoryList().remove(history); + executionStepListExecutionStep = em.merge(executionStepListExecutionStep); + } + em.remove(history); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findHistoryEntities() { + return findHistoryEntities(true, -1, -1); + } + + public List findHistoryEntities(int maxResults, int firstResult) { + return findHistoryEntities(false, maxResults, firstResult); + } + + private List findHistoryEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(History.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public History findHistory(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(History.class, id); + } + finally { + em.close(); + } + } + + public int getHistoryCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(History.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/InvestigationJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/InvestigationJpaController.java index 40d5a13b..16cf6165 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/InvestigationJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/InvestigationJpaController.java @@ -13,263 +13,263 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.UserHasInvestigation; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.ExceptionHasInvestigation; -import com.validation.manager.core.db.Investigation; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class InvestigationJpaController implements Serializable { - - public InvestigationJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(Investigation investigation) { - if (investigation.getUserHasInvestigationList() == null) { - investigation.setUserHasInvestigationList(new ArrayList()); - } - if (investigation.getExceptionHasInvestigationList() == null) { - investigation.setExceptionHasInvestigationList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedUserHasInvestigationList = new ArrayList(); - for (UserHasInvestigation userHasInvestigationListUserHasInvestigationToAttach : investigation.getUserHasInvestigationList()) { - userHasInvestigationListUserHasInvestigationToAttach = em.getReference(userHasInvestigationListUserHasInvestigationToAttach.getClass(), userHasInvestigationListUserHasInvestigationToAttach.getUserHasInvestigationPK()); - attachedUserHasInvestigationList.add(userHasInvestigationListUserHasInvestigationToAttach); - } - investigation.setUserHasInvestigationList(attachedUserHasInvestigationList); - List attachedExceptionHasInvestigationList = new ArrayList(); - for (ExceptionHasInvestigation exceptionHasInvestigationListExceptionHasInvestigationToAttach : investigation.getExceptionHasInvestigationList()) { - exceptionHasInvestigationListExceptionHasInvestigationToAttach = em.getReference(exceptionHasInvestigationListExceptionHasInvestigationToAttach.getClass(), exceptionHasInvestigationListExceptionHasInvestigationToAttach.getExceptionHasInvestigationPK()); - attachedExceptionHasInvestigationList.add(exceptionHasInvestigationListExceptionHasInvestigationToAttach); - } - investigation.setExceptionHasInvestigationList(attachedExceptionHasInvestigationList); - em.persist(investigation); - for (UserHasInvestigation userHasInvestigationListUserHasInvestigation : investigation.getUserHasInvestigationList()) { - Investigation oldInvestigationOfUserHasInvestigationListUserHasInvestigation = userHasInvestigationListUserHasInvestigation.getInvestigation(); - userHasInvestigationListUserHasInvestigation.setInvestigation(investigation); - userHasInvestigationListUserHasInvestigation = em.merge(userHasInvestigationListUserHasInvestigation); - if (oldInvestigationOfUserHasInvestigationListUserHasInvestigation != null) { - oldInvestigationOfUserHasInvestigationListUserHasInvestigation.getUserHasInvestigationList().remove(userHasInvestigationListUserHasInvestigation); - oldInvestigationOfUserHasInvestigationListUserHasInvestigation = em.merge(oldInvestigationOfUserHasInvestigationListUserHasInvestigation); - } - } - for (ExceptionHasInvestigation exceptionHasInvestigationListExceptionHasInvestigation : investigation.getExceptionHasInvestigationList()) { - Investigation oldInvestigationOfExceptionHasInvestigationListExceptionHasInvestigation = exceptionHasInvestigationListExceptionHasInvestigation.getInvestigation(); - exceptionHasInvestigationListExceptionHasInvestigation.setInvestigation(investigation); - exceptionHasInvestigationListExceptionHasInvestigation = em.merge(exceptionHasInvestigationListExceptionHasInvestigation); - if (oldInvestigationOfExceptionHasInvestigationListExceptionHasInvestigation != null) { - oldInvestigationOfExceptionHasInvestigationListExceptionHasInvestigation.getExceptionHasInvestigationList().remove(exceptionHasInvestigationListExceptionHasInvestigation); - oldInvestigationOfExceptionHasInvestigationListExceptionHasInvestigation = em.merge(oldInvestigationOfExceptionHasInvestigationListExceptionHasInvestigation); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(Investigation investigation) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Investigation persistentInvestigation = em.find(Investigation.class, investigation.getId()); - List userHasInvestigationListOld = persistentInvestigation.getUserHasInvestigationList(); - List userHasInvestigationListNew = investigation.getUserHasInvestigationList(); - List exceptionHasInvestigationListOld = persistentInvestigation.getExceptionHasInvestigationList(); - List exceptionHasInvestigationListNew = investigation.getExceptionHasInvestigationList(); - List illegalOrphanMessages = null; - for (UserHasInvestigation userHasInvestigationListOldUserHasInvestigation : userHasInvestigationListOld) { - if (!userHasInvestigationListNew.contains(userHasInvestigationListOldUserHasInvestigation)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserHasInvestigation " + userHasInvestigationListOldUserHasInvestigation + " since its investigation field is not nullable."); - } - } - for (ExceptionHasInvestigation exceptionHasInvestigationListOldExceptionHasInvestigation : exceptionHasInvestigationListOld) { - if (!exceptionHasInvestigationListNew.contains(exceptionHasInvestigationListOldExceptionHasInvestigation)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExceptionHasInvestigation " + exceptionHasInvestigationListOldExceptionHasInvestigation + " since its investigation field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedUserHasInvestigationListNew = new ArrayList(); - for (UserHasInvestigation userHasInvestigationListNewUserHasInvestigationToAttach : userHasInvestigationListNew) { - userHasInvestigationListNewUserHasInvestigationToAttach = em.getReference(userHasInvestigationListNewUserHasInvestigationToAttach.getClass(), userHasInvestigationListNewUserHasInvestigationToAttach.getUserHasInvestigationPK()); - attachedUserHasInvestigationListNew.add(userHasInvestigationListNewUserHasInvestigationToAttach); - } - userHasInvestigationListNew = attachedUserHasInvestigationListNew; - investigation.setUserHasInvestigationList(userHasInvestigationListNew); - List attachedExceptionHasInvestigationListNew = new ArrayList(); - for (ExceptionHasInvestigation exceptionHasInvestigationListNewExceptionHasInvestigationToAttach : exceptionHasInvestigationListNew) { - exceptionHasInvestigationListNewExceptionHasInvestigationToAttach = em.getReference(exceptionHasInvestigationListNewExceptionHasInvestigationToAttach.getClass(), exceptionHasInvestigationListNewExceptionHasInvestigationToAttach.getExceptionHasInvestigationPK()); - attachedExceptionHasInvestigationListNew.add(exceptionHasInvestigationListNewExceptionHasInvestigationToAttach); - } - exceptionHasInvestigationListNew = attachedExceptionHasInvestigationListNew; - investigation.setExceptionHasInvestigationList(exceptionHasInvestigationListNew); - investigation = em.merge(investigation); - for (UserHasInvestigation userHasInvestigationListNewUserHasInvestigation : userHasInvestigationListNew) { - if (!userHasInvestigationListOld.contains(userHasInvestigationListNewUserHasInvestigation)) { - Investigation oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation = userHasInvestigationListNewUserHasInvestigation.getInvestigation(); - userHasInvestigationListNewUserHasInvestigation.setInvestigation(investigation); - userHasInvestigationListNewUserHasInvestigation = em.merge(userHasInvestigationListNewUserHasInvestigation); - if (oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation != null && !oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation.equals(investigation)) { - oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation.getUserHasInvestigationList().remove(userHasInvestigationListNewUserHasInvestigation); - oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation = em.merge(oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation); - } - } - } - for (ExceptionHasInvestigation exceptionHasInvestigationListNewExceptionHasInvestigation : exceptionHasInvestigationListNew) { - if (!exceptionHasInvestigationListOld.contains(exceptionHasInvestigationListNewExceptionHasInvestigation)) { - Investigation oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation = exceptionHasInvestigationListNewExceptionHasInvestigation.getInvestigation(); - exceptionHasInvestigationListNewExceptionHasInvestigation.setInvestigation(investigation); - exceptionHasInvestigationListNewExceptionHasInvestigation = em.merge(exceptionHasInvestigationListNewExceptionHasInvestigation); - if (oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation != null && !oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation.equals(investigation)) { - oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation.getExceptionHasInvestigationList().remove(exceptionHasInvestigationListNewExceptionHasInvestigation); - oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation = em.merge(oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = investigation.getId(); - if (findInvestigation(id) == null) { - throw new NonexistentEntityException("The investigation with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Investigation investigation; - try { - investigation = em.getReference(Investigation.class, id); - investigation.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The investigation with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List userHasInvestigationListOrphanCheck = investigation.getUserHasInvestigationList(); - for (UserHasInvestigation userHasInvestigationListOrphanCheckUserHasInvestigation : userHasInvestigationListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Investigation (" + investigation + ") cannot be destroyed since the UserHasInvestigation " + userHasInvestigationListOrphanCheckUserHasInvestigation + " in its userHasInvestigationList field has a non-nullable investigation field."); - } - List exceptionHasInvestigationListOrphanCheck = investigation.getExceptionHasInvestigationList(); - for (ExceptionHasInvestigation exceptionHasInvestigationListOrphanCheckExceptionHasInvestigation : exceptionHasInvestigationListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Investigation (" + investigation + ") cannot be destroyed since the ExceptionHasInvestigation " + exceptionHasInvestigationListOrphanCheckExceptionHasInvestigation + " in its exceptionHasInvestigationList field has a non-nullable investigation field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(investigation); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findInvestigationEntities() { - return findInvestigationEntities(true, -1, -1); - } - - public List findInvestigationEntities(int maxResults, int firstResult) { - return findInvestigationEntities(false, maxResults, firstResult); - } - - private List findInvestigationEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(Investigation.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public Investigation findInvestigation(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(Investigation.class, id); - } - finally { - em.close(); - } - } - - public int getInvestigationCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(Investigation.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.UserHasInvestigation; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.ExceptionHasInvestigation; +import com.validation.manager.core.db.Investigation; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class InvestigationJpaController implements Serializable { + + public InvestigationJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(Investigation investigation) { + if (investigation.getUserHasInvestigationList() == null) { + investigation.setUserHasInvestigationList(new ArrayList<>()); + } + if (investigation.getExceptionHasInvestigationList() == null) { + investigation.setExceptionHasInvestigationList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedUserHasInvestigationList = new ArrayList<>(); + for (UserHasInvestigation userHasInvestigationListUserHasInvestigationToAttach : investigation.getUserHasInvestigationList()) { + userHasInvestigationListUserHasInvestigationToAttach = em.getReference(userHasInvestigationListUserHasInvestigationToAttach.getClass(), userHasInvestigationListUserHasInvestigationToAttach.getUserHasInvestigationPK()); + attachedUserHasInvestigationList.add(userHasInvestigationListUserHasInvestigationToAttach); + } + investigation.setUserHasInvestigationList(attachedUserHasInvestigationList); + List attachedExceptionHasInvestigationList = new ArrayList<>(); + for (ExceptionHasInvestigation exceptionHasInvestigationListExceptionHasInvestigationToAttach : investigation.getExceptionHasInvestigationList()) { + exceptionHasInvestigationListExceptionHasInvestigationToAttach = em.getReference(exceptionHasInvestigationListExceptionHasInvestigationToAttach.getClass(), exceptionHasInvestigationListExceptionHasInvestigationToAttach.getExceptionHasInvestigationPK()); + attachedExceptionHasInvestigationList.add(exceptionHasInvestigationListExceptionHasInvestigationToAttach); + } + investigation.setExceptionHasInvestigationList(attachedExceptionHasInvestigationList); + em.persist(investigation); + for (UserHasInvestigation userHasInvestigationListUserHasInvestigation : investigation.getUserHasInvestigationList()) { + Investigation oldInvestigationOfUserHasInvestigationListUserHasInvestigation = userHasInvestigationListUserHasInvestigation.getInvestigation(); + userHasInvestigationListUserHasInvestigation.setInvestigation(investigation); + userHasInvestigationListUserHasInvestigation = em.merge(userHasInvestigationListUserHasInvestigation); + if (oldInvestigationOfUserHasInvestigationListUserHasInvestigation != null) { + oldInvestigationOfUserHasInvestigationListUserHasInvestigation.getUserHasInvestigationList().remove(userHasInvestigationListUserHasInvestigation); + oldInvestigationOfUserHasInvestigationListUserHasInvestigation = em.merge(oldInvestigationOfUserHasInvestigationListUserHasInvestigation); + } + } + for (ExceptionHasInvestigation exceptionHasInvestigationListExceptionHasInvestigation : investigation.getExceptionHasInvestigationList()) { + Investigation oldInvestigationOfExceptionHasInvestigationListExceptionHasInvestigation = exceptionHasInvestigationListExceptionHasInvestigation.getInvestigation(); + exceptionHasInvestigationListExceptionHasInvestigation.setInvestigation(investigation); + exceptionHasInvestigationListExceptionHasInvestigation = em.merge(exceptionHasInvestigationListExceptionHasInvestigation); + if (oldInvestigationOfExceptionHasInvestigationListExceptionHasInvestigation != null) { + oldInvestigationOfExceptionHasInvestigationListExceptionHasInvestigation.getExceptionHasInvestigationList().remove(exceptionHasInvestigationListExceptionHasInvestigation); + oldInvestigationOfExceptionHasInvestigationListExceptionHasInvestigation = em.merge(oldInvestigationOfExceptionHasInvestigationListExceptionHasInvestigation); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(Investigation investigation) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Investigation persistentInvestigation = em.find(Investigation.class, investigation.getId()); + List userHasInvestigationListOld = persistentInvestigation.getUserHasInvestigationList(); + List userHasInvestigationListNew = investigation.getUserHasInvestigationList(); + List exceptionHasInvestigationListOld = persistentInvestigation.getExceptionHasInvestigationList(); + List exceptionHasInvestigationListNew = investigation.getExceptionHasInvestigationList(); + List illegalOrphanMessages = null; + for (UserHasInvestigation userHasInvestigationListOldUserHasInvestigation : userHasInvestigationListOld) { + if (!userHasInvestigationListNew.contains(userHasInvestigationListOldUserHasInvestigation)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserHasInvestigation " + userHasInvestigationListOldUserHasInvestigation + " since its investigation field is not nullable."); + } + } + for (ExceptionHasInvestigation exceptionHasInvestigationListOldExceptionHasInvestigation : exceptionHasInvestigationListOld) { + if (!exceptionHasInvestigationListNew.contains(exceptionHasInvestigationListOldExceptionHasInvestigation)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExceptionHasInvestigation " + exceptionHasInvestigationListOldExceptionHasInvestigation + " since its investigation field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedUserHasInvestigationListNew = new ArrayList<>(); + for (UserHasInvestigation userHasInvestigationListNewUserHasInvestigationToAttach : userHasInvestigationListNew) { + userHasInvestigationListNewUserHasInvestigationToAttach = em.getReference(userHasInvestigationListNewUserHasInvestigationToAttach.getClass(), userHasInvestigationListNewUserHasInvestigationToAttach.getUserHasInvestigationPK()); + attachedUserHasInvestigationListNew.add(userHasInvestigationListNewUserHasInvestigationToAttach); + } + userHasInvestigationListNew = attachedUserHasInvestigationListNew; + investigation.setUserHasInvestigationList(userHasInvestigationListNew); + List attachedExceptionHasInvestigationListNew = new ArrayList<>(); + for (ExceptionHasInvestigation exceptionHasInvestigationListNewExceptionHasInvestigationToAttach : exceptionHasInvestigationListNew) { + exceptionHasInvestigationListNewExceptionHasInvestigationToAttach = em.getReference(exceptionHasInvestigationListNewExceptionHasInvestigationToAttach.getClass(), exceptionHasInvestigationListNewExceptionHasInvestigationToAttach.getExceptionHasInvestigationPK()); + attachedExceptionHasInvestigationListNew.add(exceptionHasInvestigationListNewExceptionHasInvestigationToAttach); + } + exceptionHasInvestigationListNew = attachedExceptionHasInvestigationListNew; + investigation.setExceptionHasInvestigationList(exceptionHasInvestigationListNew); + investigation = em.merge(investigation); + for (UserHasInvestigation userHasInvestigationListNewUserHasInvestigation : userHasInvestigationListNew) { + if (!userHasInvestigationListOld.contains(userHasInvestigationListNewUserHasInvestigation)) { + Investigation oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation = userHasInvestigationListNewUserHasInvestigation.getInvestigation(); + userHasInvestigationListNewUserHasInvestigation.setInvestigation(investigation); + userHasInvestigationListNewUserHasInvestigation = em.merge(userHasInvestigationListNewUserHasInvestigation); + if (oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation != null && !oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation.equals(investigation)) { + oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation.getUserHasInvestigationList().remove(userHasInvestigationListNewUserHasInvestigation); + oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation = em.merge(oldInvestigationOfUserHasInvestigationListNewUserHasInvestigation); + } + } + } + for (ExceptionHasInvestigation exceptionHasInvestigationListNewExceptionHasInvestigation : exceptionHasInvestigationListNew) { + if (!exceptionHasInvestigationListOld.contains(exceptionHasInvestigationListNewExceptionHasInvestigation)) { + Investigation oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation = exceptionHasInvestigationListNewExceptionHasInvestigation.getInvestigation(); + exceptionHasInvestigationListNewExceptionHasInvestigation.setInvestigation(investigation); + exceptionHasInvestigationListNewExceptionHasInvestigation = em.merge(exceptionHasInvestigationListNewExceptionHasInvestigation); + if (oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation != null && !oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation.equals(investigation)) { + oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation.getExceptionHasInvestigationList().remove(exceptionHasInvestigationListNewExceptionHasInvestigation); + oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation = em.merge(oldInvestigationOfExceptionHasInvestigationListNewExceptionHasInvestigation); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = investigation.getId(); + if (findInvestigation(id) == null) { + throw new NonexistentEntityException("The investigation with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Investigation investigation; + try { + investigation = em.getReference(Investigation.class, id); + investigation.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The investigation with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List userHasInvestigationListOrphanCheck = investigation.getUserHasInvestigationList(); + for (UserHasInvestigation userHasInvestigationListOrphanCheckUserHasInvestigation : userHasInvestigationListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Investigation (" + investigation + ") cannot be destroyed since the UserHasInvestigation " + userHasInvestigationListOrphanCheckUserHasInvestigation + " in its userHasInvestigationList field has a non-nullable investigation field."); + } + List exceptionHasInvestigationListOrphanCheck = investigation.getExceptionHasInvestigationList(); + for (ExceptionHasInvestigation exceptionHasInvestigationListOrphanCheckExceptionHasInvestigation : exceptionHasInvestigationListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Investigation (" + investigation + ") cannot be destroyed since the ExceptionHasInvestigation " + exceptionHasInvestigationListOrphanCheckExceptionHasInvestigation + " in its exceptionHasInvestigationList field has a non-nullable investigation field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(investigation); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findInvestigationEntities() { + return findInvestigationEntities(true, -1, -1); + } + + public List findInvestigationEntities(int maxResults, int firstResult) { + return findInvestigationEntities(false, maxResults, firstResult); + } + + private List findInvestigationEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(Investigation.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public Investigation findInvestigation(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(Investigation.class, id); + } + finally { + em.close(); + } + } + + public int getInvestigationCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(Investigation.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueJpaController.java index 1e1a39a2..7dd13592 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueJpaController.java @@ -13,280 +13,280 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.IssueResolution; -import com.validation.manager.core.db.IssueType; -import com.validation.manager.core.db.ExecutionStepHasIssue; -import com.validation.manager.core.db.Issue; -import com.validation.manager.core.db.IssuePK; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class IssueJpaController implements Serializable { - - public IssueJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(Issue issue) throws PreexistingEntityException, Exception { - if (issue.getIssuePK() == null) { - issue.setIssuePK(new IssuePK()); - } - if (issue.getExecutionStepHasIssueList() == null) { - issue.setExecutionStepHasIssueList(new ArrayList()); - } - issue.getIssuePK().setIssueTypeId(issue.getIssueType().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - IssueResolution issueResolutionId = issue.getIssueResolutionId(); - if (issueResolutionId != null) { - issueResolutionId = em.getReference(issueResolutionId.getClass(), issueResolutionId.getId()); - issue.setIssueResolutionId(issueResolutionId); - } - IssueType issueType = issue.getIssueType(); - if (issueType != null) { - issueType = em.getReference(issueType.getClass(), issueType.getId()); - issue.setIssueType(issueType); - } - List attachedExecutionStepHasIssueList = new ArrayList(); - for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssueToAttach : issue.getExecutionStepHasIssueList()) { - executionStepHasIssueListExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); - attachedExecutionStepHasIssueList.add(executionStepHasIssueListExecutionStepHasIssueToAttach); - } - issue.setExecutionStepHasIssueList(attachedExecutionStepHasIssueList); - em.persist(issue); - if (issueResolutionId != null) { - issueResolutionId.getIssueList().add(issue); - issueResolutionId = em.merge(issueResolutionId); - } - if (issueType != null) { - issueType.getIssueList().add(issue); - issueType = em.merge(issueType); - } - for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssue : issue.getExecutionStepHasIssueList()) { - Issue oldIssueOfExecutionStepHasIssueListExecutionStepHasIssue = executionStepHasIssueListExecutionStepHasIssue.getIssue(); - executionStepHasIssueListExecutionStepHasIssue.setIssue(issue); - executionStepHasIssueListExecutionStepHasIssue = em.merge(executionStepHasIssueListExecutionStepHasIssue); - if (oldIssueOfExecutionStepHasIssueListExecutionStepHasIssue != null) { - oldIssueOfExecutionStepHasIssueListExecutionStepHasIssue.getExecutionStepHasIssueList().remove(executionStepHasIssueListExecutionStepHasIssue); - oldIssueOfExecutionStepHasIssueListExecutionStepHasIssue = em.merge(oldIssueOfExecutionStepHasIssueListExecutionStepHasIssue); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findIssue(issue.getIssuePK()) != null) { - throw new PreexistingEntityException("Issue " + issue + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(Issue issue) throws IllegalOrphanException, NonexistentEntityException, Exception { - issue.getIssuePK().setIssueTypeId(issue.getIssueType().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Issue persistentIssue = em.find(Issue.class, issue.getIssuePK()); - IssueResolution issueResolutionIdOld = persistentIssue.getIssueResolutionId(); - IssueResolution issueResolutionIdNew = issue.getIssueResolutionId(); - IssueType issueTypeOld = persistentIssue.getIssueType(); - IssueType issueTypeNew = issue.getIssueType(); - List executionStepHasIssueListOld = persistentIssue.getExecutionStepHasIssueList(); - List executionStepHasIssueListNew = issue.getExecutionStepHasIssueList(); - List illegalOrphanMessages = null; - for (ExecutionStepHasIssue executionStepHasIssueListOldExecutionStepHasIssue : executionStepHasIssueListOld) { - if (!executionStepHasIssueListNew.contains(executionStepHasIssueListOldExecutionStepHasIssue)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExecutionStepHasIssue " + executionStepHasIssueListOldExecutionStepHasIssue + " since its issue field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (issueResolutionIdNew != null) { - issueResolutionIdNew = em.getReference(issueResolutionIdNew.getClass(), issueResolutionIdNew.getId()); - issue.setIssueResolutionId(issueResolutionIdNew); - } - if (issueTypeNew != null) { - issueTypeNew = em.getReference(issueTypeNew.getClass(), issueTypeNew.getId()); - issue.setIssueType(issueTypeNew); - } - List attachedExecutionStepHasIssueListNew = new ArrayList(); - for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssueToAttach : executionStepHasIssueListNew) { - executionStepHasIssueListNewExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListNewExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListNewExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); - attachedExecutionStepHasIssueListNew.add(executionStepHasIssueListNewExecutionStepHasIssueToAttach); - } - executionStepHasIssueListNew = attachedExecutionStepHasIssueListNew; - issue.setExecutionStepHasIssueList(executionStepHasIssueListNew); - issue = em.merge(issue); - if (issueResolutionIdOld != null && !issueResolutionIdOld.equals(issueResolutionIdNew)) { - issueResolutionIdOld.getIssueList().remove(issue); - issueResolutionIdOld = em.merge(issueResolutionIdOld); - } - if (issueResolutionIdNew != null && !issueResolutionIdNew.equals(issueResolutionIdOld)) { - issueResolutionIdNew.getIssueList().add(issue); - issueResolutionIdNew = em.merge(issueResolutionIdNew); - } - if (issueTypeOld != null && !issueTypeOld.equals(issueTypeNew)) { - issueTypeOld.getIssueList().remove(issue); - issueTypeOld = em.merge(issueTypeOld); - } - if (issueTypeNew != null && !issueTypeNew.equals(issueTypeOld)) { - issueTypeNew.getIssueList().add(issue); - issueTypeNew = em.merge(issueTypeNew); - } - for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssue : executionStepHasIssueListNew) { - if (!executionStepHasIssueListOld.contains(executionStepHasIssueListNewExecutionStepHasIssue)) { - Issue oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue = executionStepHasIssueListNewExecutionStepHasIssue.getIssue(); - executionStepHasIssueListNewExecutionStepHasIssue.setIssue(issue); - executionStepHasIssueListNewExecutionStepHasIssue = em.merge(executionStepHasIssueListNewExecutionStepHasIssue); - if (oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue != null && !oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue.equals(issue)) { - oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue.getExecutionStepHasIssueList().remove(executionStepHasIssueListNewExecutionStepHasIssue); - oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue = em.merge(oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - IssuePK id = issue.getIssuePK(); - if (findIssue(id) == null) { - throw new NonexistentEntityException("The issue with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(IssuePK id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Issue issue; - try { - issue = em.getReference(Issue.class, id); - issue.getIssuePK(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The issue with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List executionStepHasIssueListOrphanCheck = issue.getExecutionStepHasIssueList(); - for (ExecutionStepHasIssue executionStepHasIssueListOrphanCheckExecutionStepHasIssue : executionStepHasIssueListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Issue (" + issue + ") cannot be destroyed since the ExecutionStepHasIssue " + executionStepHasIssueListOrphanCheckExecutionStepHasIssue + " in its executionStepHasIssueList field has a non-nullable issue field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - IssueResolution issueResolutionId = issue.getIssueResolutionId(); - if (issueResolutionId != null) { - issueResolutionId.getIssueList().remove(issue); - issueResolutionId = em.merge(issueResolutionId); - } - IssueType issueType = issue.getIssueType(); - if (issueType != null) { - issueType.getIssueList().remove(issue); - issueType = em.merge(issueType); - } - em.remove(issue); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findIssueEntities() { - return findIssueEntities(true, -1, -1); - } - - public List findIssueEntities(int maxResults, int firstResult) { - return findIssueEntities(false, maxResults, firstResult); - } - - private List findIssueEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(Issue.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public Issue findIssue(IssuePK id) { - EntityManager em = getEntityManager(); - try { - return em.find(Issue.class, id); - } - finally { - em.close(); - } - } - - public int getIssueCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(Issue.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.IssueResolution; +import com.validation.manager.core.db.IssueType; +import com.validation.manager.core.db.ExecutionStepHasIssue; +import com.validation.manager.core.db.Issue; +import com.validation.manager.core.db.IssuePK; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class IssueJpaController implements Serializable { + + public IssueJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(Issue issue) throws PreexistingEntityException, Exception { + if (issue.getIssuePK() == null) { + issue.setIssuePK(new IssuePK()); + } + if (issue.getExecutionStepHasIssueList() == null) { + issue.setExecutionStepHasIssueList(new ArrayList<>()); + } + issue.getIssuePK().setIssueTypeId(issue.getIssueType().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + IssueResolution issueResolutionId = issue.getIssueResolutionId(); + if (issueResolutionId != null) { + issueResolutionId = em.getReference(issueResolutionId.getClass(), issueResolutionId.getId()); + issue.setIssueResolutionId(issueResolutionId); + } + IssueType issueType = issue.getIssueType(); + if (issueType != null) { + issueType = em.getReference(issueType.getClass(), issueType.getId()); + issue.setIssueType(issueType); + } + List attachedExecutionStepHasIssueList = new ArrayList<>(); + for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssueToAttach : issue.getExecutionStepHasIssueList()) { + executionStepHasIssueListExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); + attachedExecutionStepHasIssueList.add(executionStepHasIssueListExecutionStepHasIssueToAttach); + } + issue.setExecutionStepHasIssueList(attachedExecutionStepHasIssueList); + em.persist(issue); + if (issueResolutionId != null) { + issueResolutionId.getIssueList().add(issue); + issueResolutionId = em.merge(issueResolutionId); + } + if (issueType != null) { + issueType.getIssueList().add(issue); + issueType = em.merge(issueType); + } + for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssue : issue.getExecutionStepHasIssueList()) { + Issue oldIssueOfExecutionStepHasIssueListExecutionStepHasIssue = executionStepHasIssueListExecutionStepHasIssue.getIssue(); + executionStepHasIssueListExecutionStepHasIssue.setIssue(issue); + executionStepHasIssueListExecutionStepHasIssue = em.merge(executionStepHasIssueListExecutionStepHasIssue); + if (oldIssueOfExecutionStepHasIssueListExecutionStepHasIssue != null) { + oldIssueOfExecutionStepHasIssueListExecutionStepHasIssue.getExecutionStepHasIssueList().remove(executionStepHasIssueListExecutionStepHasIssue); + oldIssueOfExecutionStepHasIssueListExecutionStepHasIssue = em.merge(oldIssueOfExecutionStepHasIssueListExecutionStepHasIssue); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findIssue(issue.getIssuePK()) != null) { + throw new PreexistingEntityException("Issue " + issue + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(Issue issue) throws IllegalOrphanException, NonexistentEntityException, Exception { + issue.getIssuePK().setIssueTypeId(issue.getIssueType().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Issue persistentIssue = em.find(Issue.class, issue.getIssuePK()); + IssueResolution issueResolutionIdOld = persistentIssue.getIssueResolutionId(); + IssueResolution issueResolutionIdNew = issue.getIssueResolutionId(); + IssueType issueTypeOld = persistentIssue.getIssueType(); + IssueType issueTypeNew = issue.getIssueType(); + List executionStepHasIssueListOld = persistentIssue.getExecutionStepHasIssueList(); + List executionStepHasIssueListNew = issue.getExecutionStepHasIssueList(); + List illegalOrphanMessages = null; + for (ExecutionStepHasIssue executionStepHasIssueListOldExecutionStepHasIssue : executionStepHasIssueListOld) { + if (!executionStepHasIssueListNew.contains(executionStepHasIssueListOldExecutionStepHasIssue)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExecutionStepHasIssue " + executionStepHasIssueListOldExecutionStepHasIssue + " since its issue field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (issueResolutionIdNew != null) { + issueResolutionIdNew = em.getReference(issueResolutionIdNew.getClass(), issueResolutionIdNew.getId()); + issue.setIssueResolutionId(issueResolutionIdNew); + } + if (issueTypeNew != null) { + issueTypeNew = em.getReference(issueTypeNew.getClass(), issueTypeNew.getId()); + issue.setIssueType(issueTypeNew); + } + List attachedExecutionStepHasIssueListNew = new ArrayList<>(); + for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssueToAttach : executionStepHasIssueListNew) { + executionStepHasIssueListNewExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListNewExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListNewExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); + attachedExecutionStepHasIssueListNew.add(executionStepHasIssueListNewExecutionStepHasIssueToAttach); + } + executionStepHasIssueListNew = attachedExecutionStepHasIssueListNew; + issue.setExecutionStepHasIssueList(executionStepHasIssueListNew); + issue = em.merge(issue); + if (issueResolutionIdOld != null && !issueResolutionIdOld.equals(issueResolutionIdNew)) { + issueResolutionIdOld.getIssueList().remove(issue); + issueResolutionIdOld = em.merge(issueResolutionIdOld); + } + if (issueResolutionIdNew != null && !issueResolutionIdNew.equals(issueResolutionIdOld)) { + issueResolutionIdNew.getIssueList().add(issue); + issueResolutionIdNew = em.merge(issueResolutionIdNew); + } + if (issueTypeOld != null && !issueTypeOld.equals(issueTypeNew)) { + issueTypeOld.getIssueList().remove(issue); + issueTypeOld = em.merge(issueTypeOld); + } + if (issueTypeNew != null && !issueTypeNew.equals(issueTypeOld)) { + issueTypeNew.getIssueList().add(issue); + issueTypeNew = em.merge(issueTypeNew); + } + for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssue : executionStepHasIssueListNew) { + if (!executionStepHasIssueListOld.contains(executionStepHasIssueListNewExecutionStepHasIssue)) { + Issue oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue = executionStepHasIssueListNewExecutionStepHasIssue.getIssue(); + executionStepHasIssueListNewExecutionStepHasIssue.setIssue(issue); + executionStepHasIssueListNewExecutionStepHasIssue = em.merge(executionStepHasIssueListNewExecutionStepHasIssue); + if (oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue != null && !oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue.equals(issue)) { + oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue.getExecutionStepHasIssueList().remove(executionStepHasIssueListNewExecutionStepHasIssue); + oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue = em.merge(oldIssueOfExecutionStepHasIssueListNewExecutionStepHasIssue); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + IssuePK id = issue.getIssuePK(); + if (findIssue(id) == null) { + throw new NonexistentEntityException("The issue with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(IssuePK id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Issue issue; + try { + issue = em.getReference(Issue.class, id); + issue.getIssuePK(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The issue with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List executionStepHasIssueListOrphanCheck = issue.getExecutionStepHasIssueList(); + for (ExecutionStepHasIssue executionStepHasIssueListOrphanCheckExecutionStepHasIssue : executionStepHasIssueListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Issue (" + issue + ") cannot be destroyed since the ExecutionStepHasIssue " + executionStepHasIssueListOrphanCheckExecutionStepHasIssue + " in its executionStepHasIssueList field has a non-nullable issue field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + IssueResolution issueResolutionId = issue.getIssueResolutionId(); + if (issueResolutionId != null) { + issueResolutionId.getIssueList().remove(issue); + issueResolutionId = em.merge(issueResolutionId); + } + IssueType issueType = issue.getIssueType(); + if (issueType != null) { + issueType.getIssueList().remove(issue); + issueType = em.merge(issueType); + } + em.remove(issue); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findIssueEntities() { + return findIssueEntities(true, -1, -1); + } + + public List findIssueEntities(int maxResults, int firstResult) { + return findIssueEntities(false, maxResults, firstResult); + } + + private List findIssueEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(Issue.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public Issue findIssue(IssuePK id) { + EntityManager em = getEntityManager(); + try { + return em.find(Issue.class, id); + } + finally { + em.close(); + } + } + + public int getIssueCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(Issue.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueResolutionJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueResolutionJpaController.java index 261af4bf..9a959957 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueResolutionJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueResolutionJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Issue; -import com.validation.manager.core.db.IssueResolution; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class IssueResolutionJpaController implements Serializable { - - public IssueResolutionJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(IssueResolution issueResolution) { - if (issueResolution.getIssueList() == null) { - issueResolution.setIssueList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedIssueList = new ArrayList(); - for (Issue issueListIssueToAttach : issueResolution.getIssueList()) { - issueListIssueToAttach = em.getReference(issueListIssueToAttach.getClass(), issueListIssueToAttach.getIssuePK()); - attachedIssueList.add(issueListIssueToAttach); - } - issueResolution.setIssueList(attachedIssueList); - em.persist(issueResolution); - for (Issue issueListIssue : issueResolution.getIssueList()) { - IssueResolution oldIssueResolutionIdOfIssueListIssue = issueListIssue.getIssueResolutionId(); - issueListIssue.setIssueResolutionId(issueResolution); - issueListIssue = em.merge(issueListIssue); - if (oldIssueResolutionIdOfIssueListIssue != null) { - oldIssueResolutionIdOfIssueListIssue.getIssueList().remove(issueListIssue); - oldIssueResolutionIdOfIssueListIssue = em.merge(oldIssueResolutionIdOfIssueListIssue); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(IssueResolution issueResolution) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - IssueResolution persistentIssueResolution = em.find(IssueResolution.class, issueResolution.getId()); - List issueListOld = persistentIssueResolution.getIssueList(); - List issueListNew = issueResolution.getIssueList(); - List illegalOrphanMessages = null; - for (Issue issueListOldIssue : issueListOld) { - if (!issueListNew.contains(issueListOldIssue)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain Issue " + issueListOldIssue + " since its issueResolutionId field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedIssueListNew = new ArrayList(); - for (Issue issueListNewIssueToAttach : issueListNew) { - issueListNewIssueToAttach = em.getReference(issueListNewIssueToAttach.getClass(), issueListNewIssueToAttach.getIssuePK()); - attachedIssueListNew.add(issueListNewIssueToAttach); - } - issueListNew = attachedIssueListNew; - issueResolution.setIssueList(issueListNew); - issueResolution = em.merge(issueResolution); - for (Issue issueListNewIssue : issueListNew) { - if (!issueListOld.contains(issueListNewIssue)) { - IssueResolution oldIssueResolutionIdOfIssueListNewIssue = issueListNewIssue.getIssueResolutionId(); - issueListNewIssue.setIssueResolutionId(issueResolution); - issueListNewIssue = em.merge(issueListNewIssue); - if (oldIssueResolutionIdOfIssueListNewIssue != null && !oldIssueResolutionIdOfIssueListNewIssue.equals(issueResolution)) { - oldIssueResolutionIdOfIssueListNewIssue.getIssueList().remove(issueListNewIssue); - oldIssueResolutionIdOfIssueListNewIssue = em.merge(oldIssueResolutionIdOfIssueListNewIssue); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = issueResolution.getId(); - if (findIssueResolution(id) == null) { - throw new NonexistentEntityException("The issueResolution with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - IssueResolution issueResolution; - try { - issueResolution = em.getReference(IssueResolution.class, id); - issueResolution.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The issueResolution with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List issueListOrphanCheck = issueResolution.getIssueList(); - for (Issue issueListOrphanCheckIssue : issueListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This IssueResolution (" + issueResolution + ") cannot be destroyed since the Issue " + issueListOrphanCheckIssue + " in its issueList field has a non-nullable issueResolutionId field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(issueResolution); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findIssueResolutionEntities() { - return findIssueResolutionEntities(true, -1, -1); - } - - public List findIssueResolutionEntities(int maxResults, int firstResult) { - return findIssueResolutionEntities(false, maxResults, firstResult); - } - - private List findIssueResolutionEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(IssueResolution.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public IssueResolution findIssueResolution(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(IssueResolution.class, id); - } - finally { - em.close(); - } - } - - public int getIssueResolutionCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(IssueResolution.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Issue; +import com.validation.manager.core.db.IssueResolution; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class IssueResolutionJpaController implements Serializable { + + public IssueResolutionJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(IssueResolution issueResolution) { + if (issueResolution.getIssueList() == null) { + issueResolution.setIssueList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedIssueList = new ArrayList<>(); + for (Issue issueListIssueToAttach : issueResolution.getIssueList()) { + issueListIssueToAttach = em.getReference(issueListIssueToAttach.getClass(), issueListIssueToAttach.getIssuePK()); + attachedIssueList.add(issueListIssueToAttach); + } + issueResolution.setIssueList(attachedIssueList); + em.persist(issueResolution); + for (Issue issueListIssue : issueResolution.getIssueList()) { + IssueResolution oldIssueResolutionIdOfIssueListIssue = issueListIssue.getIssueResolutionId(); + issueListIssue.setIssueResolutionId(issueResolution); + issueListIssue = em.merge(issueListIssue); + if (oldIssueResolutionIdOfIssueListIssue != null) { + oldIssueResolutionIdOfIssueListIssue.getIssueList().remove(issueListIssue); + oldIssueResolutionIdOfIssueListIssue = em.merge(oldIssueResolutionIdOfIssueListIssue); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(IssueResolution issueResolution) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + IssueResolution persistentIssueResolution = em.find(IssueResolution.class, issueResolution.getId()); + List issueListOld = persistentIssueResolution.getIssueList(); + List issueListNew = issueResolution.getIssueList(); + List illegalOrphanMessages = null; + for (Issue issueListOldIssue : issueListOld) { + if (!issueListNew.contains(issueListOldIssue)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain Issue " + issueListOldIssue + " since its issueResolutionId field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedIssueListNew = new ArrayList<>(); + for (Issue issueListNewIssueToAttach : issueListNew) { + issueListNewIssueToAttach = em.getReference(issueListNewIssueToAttach.getClass(), issueListNewIssueToAttach.getIssuePK()); + attachedIssueListNew.add(issueListNewIssueToAttach); + } + issueListNew = attachedIssueListNew; + issueResolution.setIssueList(issueListNew); + issueResolution = em.merge(issueResolution); + for (Issue issueListNewIssue : issueListNew) { + if (!issueListOld.contains(issueListNewIssue)) { + IssueResolution oldIssueResolutionIdOfIssueListNewIssue = issueListNewIssue.getIssueResolutionId(); + issueListNewIssue.setIssueResolutionId(issueResolution); + issueListNewIssue = em.merge(issueListNewIssue); + if (oldIssueResolutionIdOfIssueListNewIssue != null && !oldIssueResolutionIdOfIssueListNewIssue.equals(issueResolution)) { + oldIssueResolutionIdOfIssueListNewIssue.getIssueList().remove(issueListNewIssue); + oldIssueResolutionIdOfIssueListNewIssue = em.merge(oldIssueResolutionIdOfIssueListNewIssue); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = issueResolution.getId(); + if (findIssueResolution(id) == null) { + throw new NonexistentEntityException("The issueResolution with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + IssueResolution issueResolution; + try { + issueResolution = em.getReference(IssueResolution.class, id); + issueResolution.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The issueResolution with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List issueListOrphanCheck = issueResolution.getIssueList(); + for (Issue issueListOrphanCheckIssue : issueListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This IssueResolution (" + issueResolution + ") cannot be destroyed since the Issue " + issueListOrphanCheckIssue + " in its issueList field has a non-nullable issueResolutionId field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(issueResolution); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findIssueResolutionEntities() { + return findIssueResolutionEntities(true, -1, -1); + } + + public List findIssueResolutionEntities(int maxResults, int firstResult) { + return findIssueResolutionEntities(false, maxResults, firstResult); + } + + private List findIssueResolutionEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(IssueResolution.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public IssueResolution findIssueResolution(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(IssueResolution.class, id); + } + finally { + em.close(); + } + } + + public int getIssueResolutionCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(IssueResolution.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueTypeJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueTypeJpaController.java index baadbdf6..194c050a 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueTypeJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/IssueTypeJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Issue; -import com.validation.manager.core.db.IssueType; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class IssueTypeJpaController implements Serializable { - - public IssueTypeJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(IssueType issueType) { - if (issueType.getIssueList() == null) { - issueType.setIssueList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedIssueList = new ArrayList(); - for (Issue issueListIssueToAttach : issueType.getIssueList()) { - issueListIssueToAttach = em.getReference(issueListIssueToAttach.getClass(), issueListIssueToAttach.getIssuePK()); - attachedIssueList.add(issueListIssueToAttach); - } - issueType.setIssueList(attachedIssueList); - em.persist(issueType); - for (Issue issueListIssue : issueType.getIssueList()) { - IssueType oldIssueTypeOfIssueListIssue = issueListIssue.getIssueType(); - issueListIssue.setIssueType(issueType); - issueListIssue = em.merge(issueListIssue); - if (oldIssueTypeOfIssueListIssue != null) { - oldIssueTypeOfIssueListIssue.getIssueList().remove(issueListIssue); - oldIssueTypeOfIssueListIssue = em.merge(oldIssueTypeOfIssueListIssue); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(IssueType issueType) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - IssueType persistentIssueType = em.find(IssueType.class, issueType.getId()); - List issueListOld = persistentIssueType.getIssueList(); - List issueListNew = issueType.getIssueList(); - List illegalOrphanMessages = null; - for (Issue issueListOldIssue : issueListOld) { - if (!issueListNew.contains(issueListOldIssue)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain Issue " + issueListOldIssue + " since its issueType field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedIssueListNew = new ArrayList(); - for (Issue issueListNewIssueToAttach : issueListNew) { - issueListNewIssueToAttach = em.getReference(issueListNewIssueToAttach.getClass(), issueListNewIssueToAttach.getIssuePK()); - attachedIssueListNew.add(issueListNewIssueToAttach); - } - issueListNew = attachedIssueListNew; - issueType.setIssueList(issueListNew); - issueType = em.merge(issueType); - for (Issue issueListNewIssue : issueListNew) { - if (!issueListOld.contains(issueListNewIssue)) { - IssueType oldIssueTypeOfIssueListNewIssue = issueListNewIssue.getIssueType(); - issueListNewIssue.setIssueType(issueType); - issueListNewIssue = em.merge(issueListNewIssue); - if (oldIssueTypeOfIssueListNewIssue != null && !oldIssueTypeOfIssueListNewIssue.equals(issueType)) { - oldIssueTypeOfIssueListNewIssue.getIssueList().remove(issueListNewIssue); - oldIssueTypeOfIssueListNewIssue = em.merge(oldIssueTypeOfIssueListNewIssue); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = issueType.getId(); - if (findIssueType(id) == null) { - throw new NonexistentEntityException("The issueType with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - IssueType issueType; - try { - issueType = em.getReference(IssueType.class, id); - issueType.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The issueType with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List issueListOrphanCheck = issueType.getIssueList(); - for (Issue issueListOrphanCheckIssue : issueListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This IssueType (" + issueType + ") cannot be destroyed since the Issue " + issueListOrphanCheckIssue + " in its issueList field has a non-nullable issueType field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(issueType); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findIssueTypeEntities() { - return findIssueTypeEntities(true, -1, -1); - } - - public List findIssueTypeEntities(int maxResults, int firstResult) { - return findIssueTypeEntities(false, maxResults, firstResult); - } - - private List findIssueTypeEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(IssueType.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public IssueType findIssueType(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(IssueType.class, id); - } - finally { - em.close(); - } - } - - public int getIssueTypeCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(IssueType.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Issue; +import com.validation.manager.core.db.IssueType; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class IssueTypeJpaController implements Serializable { + + public IssueTypeJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(IssueType issueType) { + if (issueType.getIssueList() == null) { + issueType.setIssueList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedIssueList = new ArrayList<>(); + for (Issue issueListIssueToAttach : issueType.getIssueList()) { + issueListIssueToAttach = em.getReference(issueListIssueToAttach.getClass(), issueListIssueToAttach.getIssuePK()); + attachedIssueList.add(issueListIssueToAttach); + } + issueType.setIssueList(attachedIssueList); + em.persist(issueType); + for (Issue issueListIssue : issueType.getIssueList()) { + IssueType oldIssueTypeOfIssueListIssue = issueListIssue.getIssueType(); + issueListIssue.setIssueType(issueType); + issueListIssue = em.merge(issueListIssue); + if (oldIssueTypeOfIssueListIssue != null) { + oldIssueTypeOfIssueListIssue.getIssueList().remove(issueListIssue); + oldIssueTypeOfIssueListIssue = em.merge(oldIssueTypeOfIssueListIssue); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(IssueType issueType) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + IssueType persistentIssueType = em.find(IssueType.class, issueType.getId()); + List issueListOld = persistentIssueType.getIssueList(); + List issueListNew = issueType.getIssueList(); + List illegalOrphanMessages = null; + for (Issue issueListOldIssue : issueListOld) { + if (!issueListNew.contains(issueListOldIssue)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain Issue " + issueListOldIssue + " since its issueType field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedIssueListNew = new ArrayList<>(); + for (Issue issueListNewIssueToAttach : issueListNew) { + issueListNewIssueToAttach = em.getReference(issueListNewIssueToAttach.getClass(), issueListNewIssueToAttach.getIssuePK()); + attachedIssueListNew.add(issueListNewIssueToAttach); + } + issueListNew = attachedIssueListNew; + issueType.setIssueList(issueListNew); + issueType = em.merge(issueType); + for (Issue issueListNewIssue : issueListNew) { + if (!issueListOld.contains(issueListNewIssue)) { + IssueType oldIssueTypeOfIssueListNewIssue = issueListNewIssue.getIssueType(); + issueListNewIssue.setIssueType(issueType); + issueListNewIssue = em.merge(issueListNewIssue); + if (oldIssueTypeOfIssueListNewIssue != null && !oldIssueTypeOfIssueListNewIssue.equals(issueType)) { + oldIssueTypeOfIssueListNewIssue.getIssueList().remove(issueListNewIssue); + oldIssueTypeOfIssueListNewIssue = em.merge(oldIssueTypeOfIssueListNewIssue); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = issueType.getId(); + if (findIssueType(id) == null) { + throw new NonexistentEntityException("The issueType with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + IssueType issueType; + try { + issueType = em.getReference(IssueType.class, id); + issueType.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The issueType with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List issueListOrphanCheck = issueType.getIssueList(); + for (Issue issueListOrphanCheckIssue : issueListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This IssueType (" + issueType + ") cannot be destroyed since the Issue " + issueListOrphanCheckIssue + " in its issueList field has a non-nullable issueType field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(issueType); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findIssueTypeEntities() { + return findIssueTypeEntities(true, -1, -1); + } + + public List findIssueTypeEntities(int maxResults, int firstResult) { + return findIssueTypeEntities(false, maxResults, firstResult); + } + + private List findIssueTypeEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(IssueType.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public IssueType findIssueType(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(IssueType.class, id); + } + finally { + em.close(); + } + } + + public int getIssueTypeCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(IssueType.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/NotificationTypeJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/NotificationTypeJpaController.java index 9825606e..3efeea35 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/NotificationTypeJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/NotificationTypeJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Notification; -import com.validation.manager.core.db.NotificationType; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class NotificationTypeJpaController implements Serializable { - - public NotificationTypeJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(NotificationType notificationType) { - if (notificationType.getNotificationList() == null) { - notificationType.setNotificationList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedNotificationList = new ArrayList(); - for (Notification notificationListNotificationToAttach : notificationType.getNotificationList()) { - notificationListNotificationToAttach = em.getReference(notificationListNotificationToAttach.getClass(), notificationListNotificationToAttach.getNotificationPK()); - attachedNotificationList.add(notificationListNotificationToAttach); - } - notificationType.setNotificationList(attachedNotificationList); - em.persist(notificationType); - for (Notification notificationListNotification : notificationType.getNotificationList()) { - NotificationType oldNotificationTypeOfNotificationListNotification = notificationListNotification.getNotificationType(); - notificationListNotification.setNotificationType(notificationType); - notificationListNotification = em.merge(notificationListNotification); - if (oldNotificationTypeOfNotificationListNotification != null) { - oldNotificationTypeOfNotificationListNotification.getNotificationList().remove(notificationListNotification); - oldNotificationTypeOfNotificationListNotification = em.merge(oldNotificationTypeOfNotificationListNotification); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(NotificationType notificationType) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - NotificationType persistentNotificationType = em.find(NotificationType.class, notificationType.getId()); - List notificationListOld = persistentNotificationType.getNotificationList(); - List notificationListNew = notificationType.getNotificationList(); - List illegalOrphanMessages = null; - for (Notification notificationListOldNotification : notificationListOld) { - if (!notificationListNew.contains(notificationListOldNotification)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain Notification " + notificationListOldNotification + " since its notificationType field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedNotificationListNew = new ArrayList(); - for (Notification notificationListNewNotificationToAttach : notificationListNew) { - notificationListNewNotificationToAttach = em.getReference(notificationListNewNotificationToAttach.getClass(), notificationListNewNotificationToAttach.getNotificationPK()); - attachedNotificationListNew.add(notificationListNewNotificationToAttach); - } - notificationListNew = attachedNotificationListNew; - notificationType.setNotificationList(notificationListNew); - notificationType = em.merge(notificationType); - for (Notification notificationListNewNotification : notificationListNew) { - if (!notificationListOld.contains(notificationListNewNotification)) { - NotificationType oldNotificationTypeOfNotificationListNewNotification = notificationListNewNotification.getNotificationType(); - notificationListNewNotification.setNotificationType(notificationType); - notificationListNewNotification = em.merge(notificationListNewNotification); - if (oldNotificationTypeOfNotificationListNewNotification != null && !oldNotificationTypeOfNotificationListNewNotification.equals(notificationType)) { - oldNotificationTypeOfNotificationListNewNotification.getNotificationList().remove(notificationListNewNotification); - oldNotificationTypeOfNotificationListNewNotification = em.merge(oldNotificationTypeOfNotificationListNewNotification); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = notificationType.getId(); - if (findNotificationType(id) == null) { - throw new NonexistentEntityException("The notificationType with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - NotificationType notificationType; - try { - notificationType = em.getReference(NotificationType.class, id); - notificationType.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The notificationType with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List notificationListOrphanCheck = notificationType.getNotificationList(); - for (Notification notificationListOrphanCheckNotification : notificationListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This NotificationType (" + notificationType + ") cannot be destroyed since the Notification " + notificationListOrphanCheckNotification + " in its notificationList field has a non-nullable notificationType field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(notificationType); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findNotificationTypeEntities() { - return findNotificationTypeEntities(true, -1, -1); - } - - public List findNotificationTypeEntities(int maxResults, int firstResult) { - return findNotificationTypeEntities(false, maxResults, firstResult); - } - - private List findNotificationTypeEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(NotificationType.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public NotificationType findNotificationType(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(NotificationType.class, id); - } - finally { - em.close(); - } - } - - public int getNotificationTypeCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(NotificationType.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Notification; +import com.validation.manager.core.db.NotificationType; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class NotificationTypeJpaController implements Serializable { + + public NotificationTypeJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(NotificationType notificationType) { + if (notificationType.getNotificationList() == null) { + notificationType.setNotificationList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedNotificationList = new ArrayList<>(); + for (Notification notificationListNotificationToAttach : notificationType.getNotificationList()) { + notificationListNotificationToAttach = em.getReference(notificationListNotificationToAttach.getClass(), notificationListNotificationToAttach.getNotificationPK()); + attachedNotificationList.add(notificationListNotificationToAttach); + } + notificationType.setNotificationList(attachedNotificationList); + em.persist(notificationType); + for (Notification notificationListNotification : notificationType.getNotificationList()) { + NotificationType oldNotificationTypeOfNotificationListNotification = notificationListNotification.getNotificationType(); + notificationListNotification.setNotificationType(notificationType); + notificationListNotification = em.merge(notificationListNotification); + if (oldNotificationTypeOfNotificationListNotification != null) { + oldNotificationTypeOfNotificationListNotification.getNotificationList().remove(notificationListNotification); + oldNotificationTypeOfNotificationListNotification = em.merge(oldNotificationTypeOfNotificationListNotification); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(NotificationType notificationType) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + NotificationType persistentNotificationType = em.find(NotificationType.class, notificationType.getId()); + List notificationListOld = persistentNotificationType.getNotificationList(); + List notificationListNew = notificationType.getNotificationList(); + List illegalOrphanMessages = null; + for (Notification notificationListOldNotification : notificationListOld) { + if (!notificationListNew.contains(notificationListOldNotification)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain Notification " + notificationListOldNotification + " since its notificationType field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedNotificationListNew = new ArrayList<>(); + for (Notification notificationListNewNotificationToAttach : notificationListNew) { + notificationListNewNotificationToAttach = em.getReference(notificationListNewNotificationToAttach.getClass(), notificationListNewNotificationToAttach.getNotificationPK()); + attachedNotificationListNew.add(notificationListNewNotificationToAttach); + } + notificationListNew = attachedNotificationListNew; + notificationType.setNotificationList(notificationListNew); + notificationType = em.merge(notificationType); + for (Notification notificationListNewNotification : notificationListNew) { + if (!notificationListOld.contains(notificationListNewNotification)) { + NotificationType oldNotificationTypeOfNotificationListNewNotification = notificationListNewNotification.getNotificationType(); + notificationListNewNotification.setNotificationType(notificationType); + notificationListNewNotification = em.merge(notificationListNewNotification); + if (oldNotificationTypeOfNotificationListNewNotification != null && !oldNotificationTypeOfNotificationListNewNotification.equals(notificationType)) { + oldNotificationTypeOfNotificationListNewNotification.getNotificationList().remove(notificationListNewNotification); + oldNotificationTypeOfNotificationListNewNotification = em.merge(oldNotificationTypeOfNotificationListNewNotification); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = notificationType.getId(); + if (findNotificationType(id) == null) { + throw new NonexistentEntityException("The notificationType with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + NotificationType notificationType; + try { + notificationType = em.getReference(NotificationType.class, id); + notificationType.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The notificationType with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List notificationListOrphanCheck = notificationType.getNotificationList(); + for (Notification notificationListOrphanCheckNotification : notificationListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This NotificationType (" + notificationType + ") cannot be destroyed since the Notification " + notificationListOrphanCheckNotification + " in its notificationList field has a non-nullable notificationType field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(notificationType); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findNotificationTypeEntities() { + return findNotificationTypeEntities(true, -1, -1); + } + + public List findNotificationTypeEntities(int maxResults, int firstResult) { + return findNotificationTypeEntities(false, maxResults, firstResult); + } + + private List findNotificationTypeEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(NotificationType.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public NotificationType findNotificationType(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(NotificationType.class, id); + } + finally { + em.close(); + } + } + + public int getNotificationTypeCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(NotificationType.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/ProjectJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/ProjectJpaController.java index 4940e117..87928c3a 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/ProjectJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/ProjectJpaController.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,380 +13,380 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Project; -import com.validation.manager.core.db.TestProject; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.RequirementSpec; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class ProjectJpaController implements Serializable { - - public ProjectJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(Project project) { - if (project.getTestProjectList() == null) { - project.setTestProjectList(new ArrayList()); - } - if (project.getProjectList() == null) { - project.setProjectList(new ArrayList()); - } - if (project.getRequirementSpecList() == null) { - project.setRequirementSpecList(new ArrayList()); - } - if (project.getHistoryList() == null) { - project.setHistoryList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Project parentProjectId = project.getParentProjectId(); - if (parentProjectId != null) { - parentProjectId = em.getReference(parentProjectId.getClass(), parentProjectId.getId()); - project.setParentProjectId(parentProjectId); - } - List attachedTestProjectList = new ArrayList(); - for (TestProject testProjectListTestProjectToAttach : project.getTestProjectList()) { - testProjectListTestProjectToAttach = em.getReference(testProjectListTestProjectToAttach.getClass(), testProjectListTestProjectToAttach.getId()); - attachedTestProjectList.add(testProjectListTestProjectToAttach); - } - project.setTestProjectList(attachedTestProjectList); - List attachedProjectList = new ArrayList(); - for (Project projectListProjectToAttach : project.getProjectList()) { - projectListProjectToAttach = em.getReference(projectListProjectToAttach.getClass(), projectListProjectToAttach.getId()); - attachedProjectList.add(projectListProjectToAttach); - } - project.setProjectList(attachedProjectList); - List attachedRequirementSpecList = new ArrayList(); - for (RequirementSpec requirementSpecListRequirementSpecToAttach : project.getRequirementSpecList()) { - requirementSpecListRequirementSpecToAttach = em.getReference(requirementSpecListRequirementSpecToAttach.getClass(), requirementSpecListRequirementSpecToAttach.getRequirementSpecPK()); - attachedRequirementSpecList.add(requirementSpecListRequirementSpecToAttach); - } - project.setRequirementSpecList(attachedRequirementSpecList); - List attachedHistoryList = new ArrayList(); - for (History historyListHistoryToAttach : project.getHistoryList()) { - historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); - attachedHistoryList.add(historyListHistoryToAttach); - } - project.setHistoryList(attachedHistoryList); - em.persist(project); - if (parentProjectId != null) { - parentProjectId.getProjectList().add(project); - parentProjectId = em.merge(parentProjectId); - } - for (TestProject testProjectListTestProject : project.getTestProjectList()) { - testProjectListTestProject.getProjectList().add(project); - testProjectListTestProject = em.merge(testProjectListTestProject); - } - for (Project projectListProject : project.getProjectList()) { - Project oldParentProjectIdOfProjectListProject = projectListProject.getParentProjectId(); - projectListProject.setParentProjectId(project); - projectListProject = em.merge(projectListProject); - if (oldParentProjectIdOfProjectListProject != null) { - oldParentProjectIdOfProjectListProject.getProjectList().remove(projectListProject); - oldParentProjectIdOfProjectListProject = em.merge(oldParentProjectIdOfProjectListProject); - } - } - for (RequirementSpec requirementSpecListRequirementSpec : project.getRequirementSpecList()) { - Project oldProjectOfRequirementSpecListRequirementSpec = requirementSpecListRequirementSpec.getProject(); - requirementSpecListRequirementSpec.setProject(project); - requirementSpecListRequirementSpec = em.merge(requirementSpecListRequirementSpec); - if (oldProjectOfRequirementSpecListRequirementSpec != null) { - oldProjectOfRequirementSpecListRequirementSpec.getRequirementSpecList().remove(requirementSpecListRequirementSpec); - oldProjectOfRequirementSpecListRequirementSpec = em.merge(oldProjectOfRequirementSpecListRequirementSpec); - } - } - for (History historyListHistory : project.getHistoryList()) { - Project oldProjectIdOfHistoryListHistory = historyListHistory.getProjectId(); - historyListHistory.setProjectId(project); - historyListHistory = em.merge(historyListHistory); - if (oldProjectIdOfHistoryListHistory != null) { - oldProjectIdOfHistoryListHistory.getHistoryList().remove(historyListHistory); - oldProjectIdOfHistoryListHistory = em.merge(oldProjectIdOfHistoryListHistory); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(Project project) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Project persistentProject = em.find(Project.class, project.getId()); - Project parentProjectIdOld = persistentProject.getParentProjectId(); - Project parentProjectIdNew = project.getParentProjectId(); - List testProjectListOld = persistentProject.getTestProjectList(); - List testProjectListNew = project.getTestProjectList(); - List projectListOld = persistentProject.getProjectList(); - List projectListNew = project.getProjectList(); - List requirementSpecListOld = persistentProject.getRequirementSpecList(); - List requirementSpecListNew = project.getRequirementSpecList(); - List historyListOld = persistentProject.getHistoryList(); - List historyListNew = project.getHistoryList(); - List illegalOrphanMessages = null; - for (RequirementSpec requirementSpecListOldRequirementSpec : requirementSpecListOld) { - if (!requirementSpecListNew.contains(requirementSpecListOldRequirementSpec)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RequirementSpec " + requirementSpecListOldRequirementSpec + " since its project field is not nullable."); - } - } - for (History historyListOldHistory : historyListOld) { - if (!historyListNew.contains(historyListOldHistory)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain History " + historyListOldHistory + " since its projectId field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (parentProjectIdNew != null) { - parentProjectIdNew = em.getReference(parentProjectIdNew.getClass(), parentProjectIdNew.getId()); - project.setParentProjectId(parentProjectIdNew); - } - List attachedTestProjectListNew = new ArrayList(); - for (TestProject testProjectListNewTestProjectToAttach : testProjectListNew) { - testProjectListNewTestProjectToAttach = em.getReference(testProjectListNewTestProjectToAttach.getClass(), testProjectListNewTestProjectToAttach.getId()); - attachedTestProjectListNew.add(testProjectListNewTestProjectToAttach); - } - testProjectListNew = attachedTestProjectListNew; - project.setTestProjectList(testProjectListNew); - List attachedProjectListNew = new ArrayList(); - for (Project projectListNewProjectToAttach : projectListNew) { - projectListNewProjectToAttach = em.getReference(projectListNewProjectToAttach.getClass(), projectListNewProjectToAttach.getId()); - attachedProjectListNew.add(projectListNewProjectToAttach); - } - projectListNew = attachedProjectListNew; - project.setProjectList(projectListNew); - List attachedRequirementSpecListNew = new ArrayList(); - for (RequirementSpec requirementSpecListNewRequirementSpecToAttach : requirementSpecListNew) { - requirementSpecListNewRequirementSpecToAttach = em.getReference(requirementSpecListNewRequirementSpecToAttach.getClass(), requirementSpecListNewRequirementSpecToAttach.getRequirementSpecPK()); - attachedRequirementSpecListNew.add(requirementSpecListNewRequirementSpecToAttach); - } - requirementSpecListNew = attachedRequirementSpecListNew; - project.setRequirementSpecList(requirementSpecListNew); - List attachedHistoryListNew = new ArrayList(); - for (History historyListNewHistoryToAttach : historyListNew) { - historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); - attachedHistoryListNew.add(historyListNewHistoryToAttach); - } - historyListNew = attachedHistoryListNew; - project.setHistoryList(historyListNew); - project = em.merge(project); - if (parentProjectIdOld != null && !parentProjectIdOld.equals(parentProjectIdNew)) { - parentProjectIdOld.getProjectList().remove(project); - parentProjectIdOld = em.merge(parentProjectIdOld); - } - if (parentProjectIdNew != null && !parentProjectIdNew.equals(parentProjectIdOld)) { - parentProjectIdNew.getProjectList().add(project); - parentProjectIdNew = em.merge(parentProjectIdNew); - } - for (TestProject testProjectListOldTestProject : testProjectListOld) { - if (!testProjectListNew.contains(testProjectListOldTestProject)) { - testProjectListOldTestProject.getProjectList().remove(project); - testProjectListOldTestProject = em.merge(testProjectListOldTestProject); - } - } - for (TestProject testProjectListNewTestProject : testProjectListNew) { - if (!testProjectListOld.contains(testProjectListNewTestProject)) { - testProjectListNewTestProject.getProjectList().add(project); - testProjectListNewTestProject = em.merge(testProjectListNewTestProject); - } - } - for (Project projectListOldProject : projectListOld) { - if (!projectListNew.contains(projectListOldProject)) { - projectListOldProject.setParentProjectId(null); - projectListOldProject = em.merge(projectListOldProject); - } - } - for (Project projectListNewProject : projectListNew) { - if (!projectListOld.contains(projectListNewProject)) { - Project oldParentProjectIdOfProjectListNewProject = projectListNewProject.getParentProjectId(); - projectListNewProject.setParentProjectId(project); - projectListNewProject = em.merge(projectListNewProject); - if (oldParentProjectIdOfProjectListNewProject != null && !oldParentProjectIdOfProjectListNewProject.equals(project)) { - oldParentProjectIdOfProjectListNewProject.getProjectList().remove(projectListNewProject); - oldParentProjectIdOfProjectListNewProject = em.merge(oldParentProjectIdOfProjectListNewProject); - } - } - } - for (RequirementSpec requirementSpecListNewRequirementSpec : requirementSpecListNew) { - if (!requirementSpecListOld.contains(requirementSpecListNewRequirementSpec)) { - Project oldProjectOfRequirementSpecListNewRequirementSpec = requirementSpecListNewRequirementSpec.getProject(); - requirementSpecListNewRequirementSpec.setProject(project); - requirementSpecListNewRequirementSpec = em.merge(requirementSpecListNewRequirementSpec); - if (oldProjectOfRequirementSpecListNewRequirementSpec != null && !oldProjectOfRequirementSpecListNewRequirementSpec.equals(project)) { - oldProjectOfRequirementSpecListNewRequirementSpec.getRequirementSpecList().remove(requirementSpecListNewRequirementSpec); - oldProjectOfRequirementSpecListNewRequirementSpec = em.merge(oldProjectOfRequirementSpecListNewRequirementSpec); - } - } - } - for (History historyListNewHistory : historyListNew) { - if (!historyListOld.contains(historyListNewHistory)) { - Project oldProjectIdOfHistoryListNewHistory = historyListNewHistory.getProjectId(); - historyListNewHistory.setProjectId(project); - historyListNewHistory = em.merge(historyListNewHistory); - if (oldProjectIdOfHistoryListNewHistory != null && !oldProjectIdOfHistoryListNewHistory.equals(project)) { - oldProjectIdOfHistoryListNewHistory.getHistoryList().remove(historyListNewHistory); - oldProjectIdOfHistoryListNewHistory = em.merge(oldProjectIdOfHistoryListNewHistory); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = project.getId(); - if (findProject(id) == null) { - throw new NonexistentEntityException("The project with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Project project; - try { - project = em.getReference(Project.class, id); - project.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The project with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List requirementSpecListOrphanCheck = project.getRequirementSpecList(); - for (RequirementSpec requirementSpecListOrphanCheckRequirementSpec : requirementSpecListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Project (" + project + ") cannot be destroyed since the RequirementSpec " + requirementSpecListOrphanCheckRequirementSpec + " in its requirementSpecList field has a non-nullable project field."); - } - List historyListOrphanCheck = project.getHistoryList(); - for (History historyListOrphanCheckHistory : historyListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Project (" + project + ") cannot be destroyed since the History " + historyListOrphanCheckHistory + " in its historyList field has a non-nullable projectId field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - Project parentProjectId = project.getParentProjectId(); - if (parentProjectId != null) { - parentProjectId.getProjectList().remove(project); - parentProjectId = em.merge(parentProjectId); - } - List testProjectList = project.getTestProjectList(); - for (TestProject testProjectListTestProject : testProjectList) { - testProjectListTestProject.getProjectList().remove(project); - testProjectListTestProject = em.merge(testProjectListTestProject); - } - List projectList = project.getProjectList(); - for (Project projectListProject : projectList) { - projectListProject.setParentProjectId(null); - projectListProject = em.merge(projectListProject); - } - em.remove(project); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findProjectEntities() { - return findProjectEntities(true, -1, -1); - } - - public List findProjectEntities(int maxResults, int firstResult) { - return findProjectEntities(false, maxResults, firstResult); - } - - private List findProjectEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(Project.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public Project findProject(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(Project.class, id); - } - finally { - em.close(); - } - } - - public int getProjectCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(Project.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Project; +import com.validation.manager.core.db.TestProject; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.RequirementSpec; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ProjectJpaController implements Serializable { + + public ProjectJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(Project project) { + if (project.getTestProjectList() == null) { + project.setTestProjectList(new ArrayList<>()); + } + if (project.getProjectList() == null) { + project.setProjectList(new ArrayList<>()); + } + if (project.getRequirementSpecList() == null) { + project.setRequirementSpecList(new ArrayList<>()); + } + if (project.getHistoryList() == null) { + project.setHistoryList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Project parentProjectId = project.getParentProjectId(); + if (parentProjectId != null) { + parentProjectId = em.getReference(parentProjectId.getClass(), parentProjectId.getId()); + project.setParentProjectId(parentProjectId); + } + List attachedTestProjectList = new ArrayList<>(); + for (TestProject testProjectListTestProjectToAttach : project.getTestProjectList()) { + testProjectListTestProjectToAttach = em.getReference(testProjectListTestProjectToAttach.getClass(), testProjectListTestProjectToAttach.getId()); + attachedTestProjectList.add(testProjectListTestProjectToAttach); + } + project.setTestProjectList(attachedTestProjectList); + List attachedProjectList = new ArrayList<>(); + for (Project projectListProjectToAttach : project.getProjectList()) { + projectListProjectToAttach = em.getReference(projectListProjectToAttach.getClass(), projectListProjectToAttach.getId()); + attachedProjectList.add(projectListProjectToAttach); + } + project.setProjectList(attachedProjectList); + List attachedRequirementSpecList = new ArrayList<>(); + for (RequirementSpec requirementSpecListRequirementSpecToAttach : project.getRequirementSpecList()) { + requirementSpecListRequirementSpecToAttach = em.getReference(requirementSpecListRequirementSpecToAttach.getClass(), requirementSpecListRequirementSpecToAttach.getRequirementSpecPK()); + attachedRequirementSpecList.add(requirementSpecListRequirementSpecToAttach); + } + project.setRequirementSpecList(attachedRequirementSpecList); + List attachedHistoryList = new ArrayList<>(); + for (History historyListHistoryToAttach : project.getHistoryList()) { + historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); + attachedHistoryList.add(historyListHistoryToAttach); + } + project.setHistoryList(attachedHistoryList); + em.persist(project); + if (parentProjectId != null) { + parentProjectId.getProjectList().add(project); + parentProjectId = em.merge(parentProjectId); + } + for (TestProject testProjectListTestProject : project.getTestProjectList()) { + testProjectListTestProject.getProjectList().add(project); + testProjectListTestProject = em.merge(testProjectListTestProject); + } + for (Project projectListProject : project.getProjectList()) { + Project oldParentProjectIdOfProjectListProject = projectListProject.getParentProjectId(); + projectListProject.setParentProjectId(project); + projectListProject = em.merge(projectListProject); + if (oldParentProjectIdOfProjectListProject != null) { + oldParentProjectIdOfProjectListProject.getProjectList().remove(projectListProject); + oldParentProjectIdOfProjectListProject = em.merge(oldParentProjectIdOfProjectListProject); + } + } + for (RequirementSpec requirementSpecListRequirementSpec : project.getRequirementSpecList()) { + Project oldProjectOfRequirementSpecListRequirementSpec = requirementSpecListRequirementSpec.getProject(); + requirementSpecListRequirementSpec.setProject(project); + requirementSpecListRequirementSpec = em.merge(requirementSpecListRequirementSpec); + if (oldProjectOfRequirementSpecListRequirementSpec != null) { + oldProjectOfRequirementSpecListRequirementSpec.getRequirementSpecList().remove(requirementSpecListRequirementSpec); + oldProjectOfRequirementSpecListRequirementSpec = em.merge(oldProjectOfRequirementSpecListRequirementSpec); + } + } + for (History historyListHistory : project.getHistoryList()) { + Project oldProjectIdOfHistoryListHistory = historyListHistory.getProjectId(); + historyListHistory.setProjectId(project); + historyListHistory = em.merge(historyListHistory); + if (oldProjectIdOfHistoryListHistory != null) { + oldProjectIdOfHistoryListHistory.getHistoryList().remove(historyListHistory); + oldProjectIdOfHistoryListHistory = em.merge(oldProjectIdOfHistoryListHistory); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(Project project) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Project persistentProject = em.find(Project.class, project.getId()); + Project parentProjectIdOld = persistentProject.getParentProjectId(); + Project parentProjectIdNew = project.getParentProjectId(); + List testProjectListOld = persistentProject.getTestProjectList(); + List testProjectListNew = project.getTestProjectList(); + List projectListOld = persistentProject.getProjectList(); + List projectListNew = project.getProjectList(); + List requirementSpecListOld = persistentProject.getRequirementSpecList(); + List requirementSpecListNew = project.getRequirementSpecList(); + List historyListOld = persistentProject.getHistoryList(); + List historyListNew = project.getHistoryList(); + List illegalOrphanMessages = null; + for (RequirementSpec requirementSpecListOldRequirementSpec : requirementSpecListOld) { + if (!requirementSpecListNew.contains(requirementSpecListOldRequirementSpec)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RequirementSpec " + requirementSpecListOldRequirementSpec + " since its project field is not nullable."); + } + } + for (History historyListOldHistory : historyListOld) { + if (!historyListNew.contains(historyListOldHistory)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain History " + historyListOldHistory + " since its projectId field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (parentProjectIdNew != null) { + parentProjectIdNew = em.getReference(parentProjectIdNew.getClass(), parentProjectIdNew.getId()); + project.setParentProjectId(parentProjectIdNew); + } + List attachedTestProjectListNew = new ArrayList<>(); + for (TestProject testProjectListNewTestProjectToAttach : testProjectListNew) { + testProjectListNewTestProjectToAttach = em.getReference(testProjectListNewTestProjectToAttach.getClass(), testProjectListNewTestProjectToAttach.getId()); + attachedTestProjectListNew.add(testProjectListNewTestProjectToAttach); + } + testProjectListNew = attachedTestProjectListNew; + project.setTestProjectList(testProjectListNew); + List attachedProjectListNew = new ArrayList<>(); + for (Project projectListNewProjectToAttach : projectListNew) { + projectListNewProjectToAttach = em.getReference(projectListNewProjectToAttach.getClass(), projectListNewProjectToAttach.getId()); + attachedProjectListNew.add(projectListNewProjectToAttach); + } + projectListNew = attachedProjectListNew; + project.setProjectList(projectListNew); + List attachedRequirementSpecListNew = new ArrayList<>(); + for (RequirementSpec requirementSpecListNewRequirementSpecToAttach : requirementSpecListNew) { + requirementSpecListNewRequirementSpecToAttach = em.getReference(requirementSpecListNewRequirementSpecToAttach.getClass(), requirementSpecListNewRequirementSpecToAttach.getRequirementSpecPK()); + attachedRequirementSpecListNew.add(requirementSpecListNewRequirementSpecToAttach); + } + requirementSpecListNew = attachedRequirementSpecListNew; + project.setRequirementSpecList(requirementSpecListNew); + List attachedHistoryListNew = new ArrayList<>(); + for (History historyListNewHistoryToAttach : historyListNew) { + historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); + attachedHistoryListNew.add(historyListNewHistoryToAttach); + } + historyListNew = attachedHistoryListNew; + project.setHistoryList(historyListNew); + project = em.merge(project); + if (parentProjectIdOld != null && !parentProjectIdOld.equals(parentProjectIdNew)) { + parentProjectIdOld.getProjectList().remove(project); + parentProjectIdOld = em.merge(parentProjectIdOld); + } + if (parentProjectIdNew != null && !parentProjectIdNew.equals(parentProjectIdOld)) { + parentProjectIdNew.getProjectList().add(project); + parentProjectIdNew = em.merge(parentProjectIdNew); + } + for (TestProject testProjectListOldTestProject : testProjectListOld) { + if (!testProjectListNew.contains(testProjectListOldTestProject)) { + testProjectListOldTestProject.getProjectList().remove(project); + testProjectListOldTestProject = em.merge(testProjectListOldTestProject); + } + } + for (TestProject testProjectListNewTestProject : testProjectListNew) { + if (!testProjectListOld.contains(testProjectListNewTestProject)) { + testProjectListNewTestProject.getProjectList().add(project); + testProjectListNewTestProject = em.merge(testProjectListNewTestProject); + } + } + for (Project projectListOldProject : projectListOld) { + if (!projectListNew.contains(projectListOldProject)) { + projectListOldProject.setParentProjectId(null); + projectListOldProject = em.merge(projectListOldProject); + } + } + for (Project projectListNewProject : projectListNew) { + if (!projectListOld.contains(projectListNewProject)) { + Project oldParentProjectIdOfProjectListNewProject = projectListNewProject.getParentProjectId(); + projectListNewProject.setParentProjectId(project); + projectListNewProject = em.merge(projectListNewProject); + if (oldParentProjectIdOfProjectListNewProject != null && !oldParentProjectIdOfProjectListNewProject.equals(project)) { + oldParentProjectIdOfProjectListNewProject.getProjectList().remove(projectListNewProject); + oldParentProjectIdOfProjectListNewProject = em.merge(oldParentProjectIdOfProjectListNewProject); + } + } + } + for (RequirementSpec requirementSpecListNewRequirementSpec : requirementSpecListNew) { + if (!requirementSpecListOld.contains(requirementSpecListNewRequirementSpec)) { + Project oldProjectOfRequirementSpecListNewRequirementSpec = requirementSpecListNewRequirementSpec.getProject(); + requirementSpecListNewRequirementSpec.setProject(project); + requirementSpecListNewRequirementSpec = em.merge(requirementSpecListNewRequirementSpec); + if (oldProjectOfRequirementSpecListNewRequirementSpec != null && !oldProjectOfRequirementSpecListNewRequirementSpec.equals(project)) { + oldProjectOfRequirementSpecListNewRequirementSpec.getRequirementSpecList().remove(requirementSpecListNewRequirementSpec); + oldProjectOfRequirementSpecListNewRequirementSpec = em.merge(oldProjectOfRequirementSpecListNewRequirementSpec); + } + } + } + for (History historyListNewHistory : historyListNew) { + if (!historyListOld.contains(historyListNewHistory)) { + Project oldProjectIdOfHistoryListNewHistory = historyListNewHistory.getProjectId(); + historyListNewHistory.setProjectId(project); + historyListNewHistory = em.merge(historyListNewHistory); + if (oldProjectIdOfHistoryListNewHistory != null && !oldProjectIdOfHistoryListNewHistory.equals(project)) { + oldProjectIdOfHistoryListNewHistory.getHistoryList().remove(historyListNewHistory); + oldProjectIdOfHistoryListNewHistory = em.merge(oldProjectIdOfHistoryListNewHistory); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = project.getId(); + if (findProject(id) == null) { + throw new NonexistentEntityException("The project with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Project project; + try { + project = em.getReference(Project.class, id); + project.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The project with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List requirementSpecListOrphanCheck = project.getRequirementSpecList(); + for (RequirementSpec requirementSpecListOrphanCheckRequirementSpec : requirementSpecListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Project (" + project + ") cannot be destroyed since the RequirementSpec " + requirementSpecListOrphanCheckRequirementSpec + " in its requirementSpecList field has a non-nullable project field."); + } + List historyListOrphanCheck = project.getHistoryList(); + for (History historyListOrphanCheckHistory : historyListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Project (" + project + ") cannot be destroyed since the History " + historyListOrphanCheckHistory + " in its historyList field has a non-nullable projectId field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + Project parentProjectId = project.getParentProjectId(); + if (parentProjectId != null) { + parentProjectId.getProjectList().remove(project); + parentProjectId = em.merge(parentProjectId); + } + List testProjectList = project.getTestProjectList(); + for (TestProject testProjectListTestProject : testProjectList) { + testProjectListTestProject.getProjectList().remove(project); + testProjectListTestProject = em.merge(testProjectListTestProject); + } + List projectList = project.getProjectList(); + for (Project projectListProject : projectList) { + projectListProject.setParentProjectId(null); + projectListProject = em.merge(projectListProject); + } + em.remove(project); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findProjectEntities() { + return findProjectEntities(true, -1, -1); + } + + public List findProjectEntities(int maxResults, int firstResult) { + return findProjectEntities(false, maxResults, firstResult); + } + + private List findProjectEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(Project.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public Project findProject(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(Project.class, id); + } + finally { + em.close(); + } + } + + public int getProjectCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(Project.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementJpaController.java index c18f7889..4e95c09a 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementJpaController.java @@ -13,463 +13,463 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Requirement; -import com.validation.manager.core.db.RequirementSpecNode; -import com.validation.manager.core.db.RequirementStatus; -import com.validation.manager.core.db.RequirementType; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.Step; -import com.validation.manager.core.db.RiskControlHasRequirement; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RequirementJpaController implements Serializable { - - public RequirementJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(Requirement requirement) { - if (requirement.getRequirementList() == null) { - requirement.setRequirementList(new ArrayList()); - } - if (requirement.getStepList() == null) { - requirement.setStepList(new ArrayList()); - } - if (requirement.getRiskControlHasRequirementList() == null) { - requirement.setRiskControlHasRequirementList(new ArrayList()); - } - if (requirement.getHistoryList() == null) { - requirement.setHistoryList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Requirement parentRequirementId = requirement.getParentRequirementId(); - if (parentRequirementId != null) { - parentRequirementId = em.getReference(parentRequirementId.getClass(), parentRequirementId.getId()); - requirement.setParentRequirementId(parentRequirementId); - } - RequirementSpecNode requirementSpecNode = requirement.getRequirementSpecNode(); - if (requirementSpecNode != null) { - requirementSpecNode = em.getReference(requirementSpecNode.getClass(), requirementSpecNode.getRequirementSpecNodePK()); - requirement.setRequirementSpecNode(requirementSpecNode); - } - RequirementStatus requirementStatusId = requirement.getRequirementStatusId(); - if (requirementStatusId != null) { - requirementStatusId = em.getReference(requirementStatusId.getClass(), requirementStatusId.getId()); - requirement.setRequirementStatusId(requirementStatusId); - } - RequirementType requirementTypeId = requirement.getRequirementTypeId(); - if (requirementTypeId != null) { - requirementTypeId = em.getReference(requirementTypeId.getClass(), requirementTypeId.getId()); - requirement.setRequirementTypeId(requirementTypeId); - } - List attachedRequirementList = new ArrayList(); - for (Requirement requirementListRequirementToAttach : requirement.getRequirementList()) { - requirementListRequirementToAttach = em.getReference(requirementListRequirementToAttach.getClass(), requirementListRequirementToAttach.getId()); - attachedRequirementList.add(requirementListRequirementToAttach); - } - requirement.setRequirementList(attachedRequirementList); - List attachedStepList = new ArrayList(); - for (Step stepListStepToAttach : requirement.getStepList()) { - stepListStepToAttach = em.getReference(stepListStepToAttach.getClass(), stepListStepToAttach.getStepPK()); - attachedStepList.add(stepListStepToAttach); - } - requirement.setStepList(attachedStepList); - List attachedRiskControlHasRequirementList = new ArrayList(); - for (RiskControlHasRequirement riskControlHasRequirementListRiskControlHasRequirementToAttach : requirement.getRiskControlHasRequirementList()) { - riskControlHasRequirementListRiskControlHasRequirementToAttach = em.getReference(riskControlHasRequirementListRiskControlHasRequirementToAttach.getClass(), riskControlHasRequirementListRiskControlHasRequirementToAttach.getRiskControlHasRequirementPK()); - attachedRiskControlHasRequirementList.add(riskControlHasRequirementListRiskControlHasRequirementToAttach); - } - requirement.setRiskControlHasRequirementList(attachedRiskControlHasRequirementList); - List attachedHistoryList = new ArrayList(); - for (History historyListHistoryToAttach : requirement.getHistoryList()) { - historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); - attachedHistoryList.add(historyListHistoryToAttach); - } - requirement.setHistoryList(attachedHistoryList); - em.persist(requirement); - if (parentRequirementId != null) { - parentRequirementId.getRequirementList().add(requirement); - parentRequirementId = em.merge(parentRequirementId); - } - if (requirementSpecNode != null) { - requirementSpecNode.getRequirementList().add(requirement); - requirementSpecNode = em.merge(requirementSpecNode); - } - if (requirementStatusId != null) { - requirementStatusId.getRequirementList().add(requirement); - requirementStatusId = em.merge(requirementStatusId); - } - if (requirementTypeId != null) { - requirementTypeId.getRequirementList().add(requirement); - requirementTypeId = em.merge(requirementTypeId); - } - for (Requirement requirementListRequirement : requirement.getRequirementList()) { - Requirement oldParentRequirementIdOfRequirementListRequirement = requirementListRequirement.getParentRequirementId(); - requirementListRequirement.setParentRequirementId(requirement); - requirementListRequirement = em.merge(requirementListRequirement); - if (oldParentRequirementIdOfRequirementListRequirement != null) { - oldParentRequirementIdOfRequirementListRequirement.getRequirementList().remove(requirementListRequirement); - oldParentRequirementIdOfRequirementListRequirement = em.merge(oldParentRequirementIdOfRequirementListRequirement); - } - } - for (Step stepListStep : requirement.getStepList()) { - stepListStep.getRequirementList().add(requirement); - stepListStep = em.merge(stepListStep); - } - for (RiskControlHasRequirement riskControlHasRequirementListRiskControlHasRequirement : requirement.getRiskControlHasRequirementList()) { - Requirement oldRequirementOfRiskControlHasRequirementListRiskControlHasRequirement = riskControlHasRequirementListRiskControlHasRequirement.getRequirement(); - riskControlHasRequirementListRiskControlHasRequirement.setRequirement(requirement); - riskControlHasRequirementListRiskControlHasRequirement = em.merge(riskControlHasRequirementListRiskControlHasRequirement); - if (oldRequirementOfRiskControlHasRequirementListRiskControlHasRequirement != null) { - oldRequirementOfRiskControlHasRequirementListRiskControlHasRequirement.getRiskControlHasRequirementList().remove(riskControlHasRequirementListRiskControlHasRequirement); - oldRequirementOfRiskControlHasRequirementListRiskControlHasRequirement = em.merge(oldRequirementOfRiskControlHasRequirementListRiskControlHasRequirement); - } - } - for (History historyListHistory : requirement.getHistoryList()) { - Requirement oldRequirementIdOfHistoryListHistory = historyListHistory.getRequirementId(); - historyListHistory.setRequirementId(requirement); - historyListHistory = em.merge(historyListHistory); - if (oldRequirementIdOfHistoryListHistory != null) { - oldRequirementIdOfHistoryListHistory.getHistoryList().remove(historyListHistory); - oldRequirementIdOfHistoryListHistory = em.merge(oldRequirementIdOfHistoryListHistory); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(Requirement requirement) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Requirement persistentRequirement = em.find(Requirement.class, requirement.getId()); - Requirement parentRequirementIdOld = persistentRequirement.getParentRequirementId(); - Requirement parentRequirementIdNew = requirement.getParentRequirementId(); - RequirementSpecNode requirementSpecNodeOld = persistentRequirement.getRequirementSpecNode(); - RequirementSpecNode requirementSpecNodeNew = requirement.getRequirementSpecNode(); - RequirementStatus requirementStatusIdOld = persistentRequirement.getRequirementStatusId(); - RequirementStatus requirementStatusIdNew = requirement.getRequirementStatusId(); - RequirementType requirementTypeIdOld = persistentRequirement.getRequirementTypeId(); - RequirementType requirementTypeIdNew = requirement.getRequirementTypeId(); - List requirementListOld = persistentRequirement.getRequirementList(); - List requirementListNew = requirement.getRequirementList(); - List stepListOld = persistentRequirement.getStepList(); - List stepListNew = requirement.getStepList(); - List riskControlHasRequirementListOld = persistentRequirement.getRiskControlHasRequirementList(); - List riskControlHasRequirementListNew = requirement.getRiskControlHasRequirementList(); - List historyListOld = persistentRequirement.getHistoryList(); - List historyListNew = requirement.getHistoryList(); - List illegalOrphanMessages = null; - for (RiskControlHasRequirement riskControlHasRequirementListOldRiskControlHasRequirement : riskControlHasRequirementListOld) { - if (!riskControlHasRequirementListNew.contains(riskControlHasRequirementListOldRiskControlHasRequirement)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RiskControlHasRequirement " + riskControlHasRequirementListOldRiskControlHasRequirement + " since its requirement field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (parentRequirementIdNew != null) { - parentRequirementIdNew = em.getReference(parentRequirementIdNew.getClass(), parentRequirementIdNew.getId()); - requirement.setParentRequirementId(parentRequirementIdNew); - } - if (requirementSpecNodeNew != null) { - requirementSpecNodeNew = em.getReference(requirementSpecNodeNew.getClass(), requirementSpecNodeNew.getRequirementSpecNodePK()); - requirement.setRequirementSpecNode(requirementSpecNodeNew); - } - if (requirementStatusIdNew != null) { - requirementStatusIdNew = em.getReference(requirementStatusIdNew.getClass(), requirementStatusIdNew.getId()); - requirement.setRequirementStatusId(requirementStatusIdNew); - } - if (requirementTypeIdNew != null) { - requirementTypeIdNew = em.getReference(requirementTypeIdNew.getClass(), requirementTypeIdNew.getId()); - requirement.setRequirementTypeId(requirementTypeIdNew); - } - List attachedRequirementListNew = new ArrayList(); - for (Requirement requirementListNewRequirementToAttach : requirementListNew) { - requirementListNewRequirementToAttach = em.getReference(requirementListNewRequirementToAttach.getClass(), requirementListNewRequirementToAttach.getId()); - attachedRequirementListNew.add(requirementListNewRequirementToAttach); - } - requirementListNew = attachedRequirementListNew; - requirement.setRequirementList(requirementListNew); - List attachedStepListNew = new ArrayList(); - for (Step stepListNewStepToAttach : stepListNew) { - stepListNewStepToAttach = em.getReference(stepListNewStepToAttach.getClass(), stepListNewStepToAttach.getStepPK()); - attachedStepListNew.add(stepListNewStepToAttach); - } - stepListNew = attachedStepListNew; - requirement.setStepList(stepListNew); - List attachedRiskControlHasRequirementListNew = new ArrayList(); - for (RiskControlHasRequirement riskControlHasRequirementListNewRiskControlHasRequirementToAttach : riskControlHasRequirementListNew) { - riskControlHasRequirementListNewRiskControlHasRequirementToAttach = em.getReference(riskControlHasRequirementListNewRiskControlHasRequirementToAttach.getClass(), riskControlHasRequirementListNewRiskControlHasRequirementToAttach.getRiskControlHasRequirementPK()); - attachedRiskControlHasRequirementListNew.add(riskControlHasRequirementListNewRiskControlHasRequirementToAttach); - } - riskControlHasRequirementListNew = attachedRiskControlHasRequirementListNew; - requirement.setRiskControlHasRequirementList(riskControlHasRequirementListNew); - List attachedHistoryListNew = new ArrayList(); - for (History historyListNewHistoryToAttach : historyListNew) { - historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); - attachedHistoryListNew.add(historyListNewHistoryToAttach); - } - historyListNew = attachedHistoryListNew; - requirement.setHistoryList(historyListNew); - requirement = em.merge(requirement); - if (parentRequirementIdOld != null && !parentRequirementIdOld.equals(parentRequirementIdNew)) { - parentRequirementIdOld.getRequirementList().remove(requirement); - parentRequirementIdOld = em.merge(parentRequirementIdOld); - } - if (parentRequirementIdNew != null && !parentRequirementIdNew.equals(parentRequirementIdOld)) { - parentRequirementIdNew.getRequirementList().add(requirement); - parentRequirementIdNew = em.merge(parentRequirementIdNew); - } - if (requirementSpecNodeOld != null && !requirementSpecNodeOld.equals(requirementSpecNodeNew)) { - requirementSpecNodeOld.getRequirementList().remove(requirement); - requirementSpecNodeOld = em.merge(requirementSpecNodeOld); - } - if (requirementSpecNodeNew != null && !requirementSpecNodeNew.equals(requirementSpecNodeOld)) { - requirementSpecNodeNew.getRequirementList().add(requirement); - requirementSpecNodeNew = em.merge(requirementSpecNodeNew); - } - if (requirementStatusIdOld != null && !requirementStatusIdOld.equals(requirementStatusIdNew)) { - requirementStatusIdOld.getRequirementList().remove(requirement); - requirementStatusIdOld = em.merge(requirementStatusIdOld); - } - if (requirementStatusIdNew != null && !requirementStatusIdNew.equals(requirementStatusIdOld)) { - requirementStatusIdNew.getRequirementList().add(requirement); - requirementStatusIdNew = em.merge(requirementStatusIdNew); - } - if (requirementTypeIdOld != null && !requirementTypeIdOld.equals(requirementTypeIdNew)) { - requirementTypeIdOld.getRequirementList().remove(requirement); - requirementTypeIdOld = em.merge(requirementTypeIdOld); - } - if (requirementTypeIdNew != null && !requirementTypeIdNew.equals(requirementTypeIdOld)) { - requirementTypeIdNew.getRequirementList().add(requirement); - requirementTypeIdNew = em.merge(requirementTypeIdNew); - } - for (Requirement requirementListOldRequirement : requirementListOld) { - if (!requirementListNew.contains(requirementListOldRequirement)) { - requirementListOldRequirement.setParentRequirementId(null); - requirementListOldRequirement = em.merge(requirementListOldRequirement); - } - } - for (Requirement requirementListNewRequirement : requirementListNew) { - if (!requirementListOld.contains(requirementListNewRequirement)) { - Requirement oldParentRequirementIdOfRequirementListNewRequirement = requirementListNewRequirement.getParentRequirementId(); - requirementListNewRequirement.setParentRequirementId(requirement); - requirementListNewRequirement = em.merge(requirementListNewRequirement); - if (oldParentRequirementIdOfRequirementListNewRequirement != null && !oldParentRequirementIdOfRequirementListNewRequirement.equals(requirement)) { - oldParentRequirementIdOfRequirementListNewRequirement.getRequirementList().remove(requirementListNewRequirement); - oldParentRequirementIdOfRequirementListNewRequirement = em.merge(oldParentRequirementIdOfRequirementListNewRequirement); - } - } - } - for (Step stepListOldStep : stepListOld) { - if (!stepListNew.contains(stepListOldStep)) { - stepListOldStep.getRequirementList().remove(requirement); - stepListOldStep = em.merge(stepListOldStep); - } - } - for (Step stepListNewStep : stepListNew) { - if (!stepListOld.contains(stepListNewStep)) { - stepListNewStep.getRequirementList().add(requirement); - stepListNewStep = em.merge(stepListNewStep); - } - } - for (RiskControlHasRequirement riskControlHasRequirementListNewRiskControlHasRequirement : riskControlHasRequirementListNew) { - if (!riskControlHasRequirementListOld.contains(riskControlHasRequirementListNewRiskControlHasRequirement)) { - Requirement oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement = riskControlHasRequirementListNewRiskControlHasRequirement.getRequirement(); - riskControlHasRequirementListNewRiskControlHasRequirement.setRequirement(requirement); - riskControlHasRequirementListNewRiskControlHasRequirement = em.merge(riskControlHasRequirementListNewRiskControlHasRequirement); - if (oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement != null && !oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement.equals(requirement)) { - oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement.getRiskControlHasRequirementList().remove(riskControlHasRequirementListNewRiskControlHasRequirement); - oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement = em.merge(oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement); - } - } - } - for (History historyListOldHistory : historyListOld) { - if (!historyListNew.contains(historyListOldHistory)) { - historyListOldHistory.setRequirementId(null); - historyListOldHistory = em.merge(historyListOldHistory); - } - } - for (History historyListNewHistory : historyListNew) { - if (!historyListOld.contains(historyListNewHistory)) { - Requirement oldRequirementIdOfHistoryListNewHistory = historyListNewHistory.getRequirementId(); - historyListNewHistory.setRequirementId(requirement); - historyListNewHistory = em.merge(historyListNewHistory); - if (oldRequirementIdOfHistoryListNewHistory != null && !oldRequirementIdOfHistoryListNewHistory.equals(requirement)) { - oldRequirementIdOfHistoryListNewHistory.getHistoryList().remove(historyListNewHistory); - oldRequirementIdOfHistoryListNewHistory = em.merge(oldRequirementIdOfHistoryListNewHistory); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = requirement.getId(); - if (findRequirement(id) == null) { - throw new NonexistentEntityException("The requirement with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Requirement requirement; - try { - requirement = em.getReference(Requirement.class, id); - requirement.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The requirement with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List riskControlHasRequirementListOrphanCheck = requirement.getRiskControlHasRequirementList(); - for (RiskControlHasRequirement riskControlHasRequirementListOrphanCheckRiskControlHasRequirement : riskControlHasRequirementListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Requirement (" + requirement + ") cannot be destroyed since the RiskControlHasRequirement " + riskControlHasRequirementListOrphanCheckRiskControlHasRequirement + " in its riskControlHasRequirementList field has a non-nullable requirement field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - Requirement parentRequirementId = requirement.getParentRequirementId(); - if (parentRequirementId != null) { - parentRequirementId.getRequirementList().remove(requirement); - parentRequirementId = em.merge(parentRequirementId); - } - RequirementSpecNode requirementSpecNode = requirement.getRequirementSpecNode(); - if (requirementSpecNode != null) { - requirementSpecNode.getRequirementList().remove(requirement); - requirementSpecNode = em.merge(requirementSpecNode); - } - RequirementStatus requirementStatusId = requirement.getRequirementStatusId(); - if (requirementStatusId != null) { - requirementStatusId.getRequirementList().remove(requirement); - requirementStatusId = em.merge(requirementStatusId); - } - RequirementType requirementTypeId = requirement.getRequirementTypeId(); - if (requirementTypeId != null) { - requirementTypeId.getRequirementList().remove(requirement); - requirementTypeId = em.merge(requirementTypeId); - } - List requirementList = requirement.getRequirementList(); - for (Requirement requirementListRequirement : requirementList) { - requirementListRequirement.setParentRequirementId(null); - requirementListRequirement = em.merge(requirementListRequirement); - } - List stepList = requirement.getStepList(); - for (Step stepListStep : stepList) { - stepListStep.getRequirementList().remove(requirement); - stepListStep = em.merge(stepListStep); - } - List historyList = requirement.getHistoryList(); - for (History historyListHistory : historyList) { - historyListHistory.setRequirementId(null); - historyListHistory = em.merge(historyListHistory); - } - em.remove(requirement); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRequirementEntities() { - return findRequirementEntities(true, -1, -1); - } - - public List findRequirementEntities(int maxResults, int firstResult) { - return findRequirementEntities(false, maxResults, firstResult); - } - - private List findRequirementEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(Requirement.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public Requirement findRequirement(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(Requirement.class, id); - } - finally { - em.close(); - } - } - - public int getRequirementCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(Requirement.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Requirement; +import com.validation.manager.core.db.RequirementSpecNode; +import com.validation.manager.core.db.RequirementStatus; +import com.validation.manager.core.db.RequirementType; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.Step; +import com.validation.manager.core.db.RiskControlHasRequirement; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RequirementJpaController implements Serializable { + + public RequirementJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(Requirement requirement) { + if (requirement.getRequirementList() == null) { + requirement.setRequirementList(new ArrayList<>()); + } + if (requirement.getStepList() == null) { + requirement.setStepList(new ArrayList<>()); + } + if (requirement.getRiskControlHasRequirementList() == null) { + requirement.setRiskControlHasRequirementList(new ArrayList<>()); + } + if (requirement.getHistoryList() == null) { + requirement.setHistoryList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Requirement parentRequirementId = requirement.getParentRequirementId(); + if (parentRequirementId != null) { + parentRequirementId = em.getReference(parentRequirementId.getClass(), parentRequirementId.getId()); + requirement.setParentRequirementId(parentRequirementId); + } + RequirementSpecNode requirementSpecNode = requirement.getRequirementSpecNode(); + if (requirementSpecNode != null) { + requirementSpecNode = em.getReference(requirementSpecNode.getClass(), requirementSpecNode.getRequirementSpecNodePK()); + requirement.setRequirementSpecNode(requirementSpecNode); + } + RequirementStatus requirementStatusId = requirement.getRequirementStatusId(); + if (requirementStatusId != null) { + requirementStatusId = em.getReference(requirementStatusId.getClass(), requirementStatusId.getId()); + requirement.setRequirementStatusId(requirementStatusId); + } + RequirementType requirementTypeId = requirement.getRequirementTypeId(); + if (requirementTypeId != null) { + requirementTypeId = em.getReference(requirementTypeId.getClass(), requirementTypeId.getId()); + requirement.setRequirementTypeId(requirementTypeId); + } + List attachedRequirementList = new ArrayList<>(); + for (Requirement requirementListRequirementToAttach : requirement.getRequirementList()) { + requirementListRequirementToAttach = em.getReference(requirementListRequirementToAttach.getClass(), requirementListRequirementToAttach.getId()); + attachedRequirementList.add(requirementListRequirementToAttach); + } + requirement.setRequirementList(attachedRequirementList); + List attachedStepList = new ArrayList<>(); + for (Step stepListStepToAttach : requirement.getStepList()) { + stepListStepToAttach = em.getReference(stepListStepToAttach.getClass(), stepListStepToAttach.getStepPK()); + attachedStepList.add(stepListStepToAttach); + } + requirement.setStepList(attachedStepList); + List attachedRiskControlHasRequirementList = new ArrayList<>(); + for (RiskControlHasRequirement riskControlHasRequirementListRiskControlHasRequirementToAttach : requirement.getRiskControlHasRequirementList()) { + riskControlHasRequirementListRiskControlHasRequirementToAttach = em.getReference(riskControlHasRequirementListRiskControlHasRequirementToAttach.getClass(), riskControlHasRequirementListRiskControlHasRequirementToAttach.getRiskControlHasRequirementPK()); + attachedRiskControlHasRequirementList.add(riskControlHasRequirementListRiskControlHasRequirementToAttach); + } + requirement.setRiskControlHasRequirementList(attachedRiskControlHasRequirementList); + List attachedHistoryList = new ArrayList<>(); + for (History historyListHistoryToAttach : requirement.getHistoryList()) { + historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); + attachedHistoryList.add(historyListHistoryToAttach); + } + requirement.setHistoryList(attachedHistoryList); + em.persist(requirement); + if (parentRequirementId != null) { + parentRequirementId.getRequirementList().add(requirement); + parentRequirementId = em.merge(parentRequirementId); + } + if (requirementSpecNode != null) { + requirementSpecNode.getRequirementList().add(requirement); + requirementSpecNode = em.merge(requirementSpecNode); + } + if (requirementStatusId != null) { + requirementStatusId.getRequirementList().add(requirement); + requirementStatusId = em.merge(requirementStatusId); + } + if (requirementTypeId != null) { + requirementTypeId.getRequirementList().add(requirement); + requirementTypeId = em.merge(requirementTypeId); + } + for (Requirement requirementListRequirement : requirement.getRequirementList()) { + Requirement oldParentRequirementIdOfRequirementListRequirement = requirementListRequirement.getParentRequirementId(); + requirementListRequirement.setParentRequirementId(requirement); + requirementListRequirement = em.merge(requirementListRequirement); + if (oldParentRequirementIdOfRequirementListRequirement != null) { + oldParentRequirementIdOfRequirementListRequirement.getRequirementList().remove(requirementListRequirement); + oldParentRequirementIdOfRequirementListRequirement = em.merge(oldParentRequirementIdOfRequirementListRequirement); + } + } + for (Step stepListStep : requirement.getStepList()) { + stepListStep.getRequirementList().add(requirement); + stepListStep = em.merge(stepListStep); + } + for (RiskControlHasRequirement riskControlHasRequirementListRiskControlHasRequirement : requirement.getRiskControlHasRequirementList()) { + Requirement oldRequirementOfRiskControlHasRequirementListRiskControlHasRequirement = riskControlHasRequirementListRiskControlHasRequirement.getRequirement(); + riskControlHasRequirementListRiskControlHasRequirement.setRequirement(requirement); + riskControlHasRequirementListRiskControlHasRequirement = em.merge(riskControlHasRequirementListRiskControlHasRequirement); + if (oldRequirementOfRiskControlHasRequirementListRiskControlHasRequirement != null) { + oldRequirementOfRiskControlHasRequirementListRiskControlHasRequirement.getRiskControlHasRequirementList().remove(riskControlHasRequirementListRiskControlHasRequirement); + oldRequirementOfRiskControlHasRequirementListRiskControlHasRequirement = em.merge(oldRequirementOfRiskControlHasRequirementListRiskControlHasRequirement); + } + } + for (History historyListHistory : requirement.getHistoryList()) { + Requirement oldRequirementIdOfHistoryListHistory = historyListHistory.getRequirementId(); + historyListHistory.setRequirementId(requirement); + historyListHistory = em.merge(historyListHistory); + if (oldRequirementIdOfHistoryListHistory != null) { + oldRequirementIdOfHistoryListHistory.getHistoryList().remove(historyListHistory); + oldRequirementIdOfHistoryListHistory = em.merge(oldRequirementIdOfHistoryListHistory); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(Requirement requirement) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Requirement persistentRequirement = em.find(Requirement.class, requirement.getId()); + Requirement parentRequirementIdOld = persistentRequirement.getParentRequirementId(); + Requirement parentRequirementIdNew = requirement.getParentRequirementId(); + RequirementSpecNode requirementSpecNodeOld = persistentRequirement.getRequirementSpecNode(); + RequirementSpecNode requirementSpecNodeNew = requirement.getRequirementSpecNode(); + RequirementStatus requirementStatusIdOld = persistentRequirement.getRequirementStatusId(); + RequirementStatus requirementStatusIdNew = requirement.getRequirementStatusId(); + RequirementType requirementTypeIdOld = persistentRequirement.getRequirementTypeId(); + RequirementType requirementTypeIdNew = requirement.getRequirementTypeId(); + List requirementListOld = persistentRequirement.getRequirementList(); + List requirementListNew = requirement.getRequirementList(); + List stepListOld = persistentRequirement.getStepList(); + List stepListNew = requirement.getStepList(); + List riskControlHasRequirementListOld = persistentRequirement.getRiskControlHasRequirementList(); + List riskControlHasRequirementListNew = requirement.getRiskControlHasRequirementList(); + List historyListOld = persistentRequirement.getHistoryList(); + List historyListNew = requirement.getHistoryList(); + List illegalOrphanMessages = null; + for (RiskControlHasRequirement riskControlHasRequirementListOldRiskControlHasRequirement : riskControlHasRequirementListOld) { + if (!riskControlHasRequirementListNew.contains(riskControlHasRequirementListOldRiskControlHasRequirement)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RiskControlHasRequirement " + riskControlHasRequirementListOldRiskControlHasRequirement + " since its requirement field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (parentRequirementIdNew != null) { + parentRequirementIdNew = em.getReference(parentRequirementIdNew.getClass(), parentRequirementIdNew.getId()); + requirement.setParentRequirementId(parentRequirementIdNew); + } + if (requirementSpecNodeNew != null) { + requirementSpecNodeNew = em.getReference(requirementSpecNodeNew.getClass(), requirementSpecNodeNew.getRequirementSpecNodePK()); + requirement.setRequirementSpecNode(requirementSpecNodeNew); + } + if (requirementStatusIdNew != null) { + requirementStatusIdNew = em.getReference(requirementStatusIdNew.getClass(), requirementStatusIdNew.getId()); + requirement.setRequirementStatusId(requirementStatusIdNew); + } + if (requirementTypeIdNew != null) { + requirementTypeIdNew = em.getReference(requirementTypeIdNew.getClass(), requirementTypeIdNew.getId()); + requirement.setRequirementTypeId(requirementTypeIdNew); + } + List attachedRequirementListNew = new ArrayList<>(); + for (Requirement requirementListNewRequirementToAttach : requirementListNew) { + requirementListNewRequirementToAttach = em.getReference(requirementListNewRequirementToAttach.getClass(), requirementListNewRequirementToAttach.getId()); + attachedRequirementListNew.add(requirementListNewRequirementToAttach); + } + requirementListNew = attachedRequirementListNew; + requirement.setRequirementList(requirementListNew); + List attachedStepListNew = new ArrayList<>(); + for (Step stepListNewStepToAttach : stepListNew) { + stepListNewStepToAttach = em.getReference(stepListNewStepToAttach.getClass(), stepListNewStepToAttach.getStepPK()); + attachedStepListNew.add(stepListNewStepToAttach); + } + stepListNew = attachedStepListNew; + requirement.setStepList(stepListNew); + List attachedRiskControlHasRequirementListNew = new ArrayList<>(); + for (RiskControlHasRequirement riskControlHasRequirementListNewRiskControlHasRequirementToAttach : riskControlHasRequirementListNew) { + riskControlHasRequirementListNewRiskControlHasRequirementToAttach = em.getReference(riskControlHasRequirementListNewRiskControlHasRequirementToAttach.getClass(), riskControlHasRequirementListNewRiskControlHasRequirementToAttach.getRiskControlHasRequirementPK()); + attachedRiskControlHasRequirementListNew.add(riskControlHasRequirementListNewRiskControlHasRequirementToAttach); + } + riskControlHasRequirementListNew = attachedRiskControlHasRequirementListNew; + requirement.setRiskControlHasRequirementList(riskControlHasRequirementListNew); + List attachedHistoryListNew = new ArrayList<>(); + for (History historyListNewHistoryToAttach : historyListNew) { + historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); + attachedHistoryListNew.add(historyListNewHistoryToAttach); + } + historyListNew = attachedHistoryListNew; + requirement.setHistoryList(historyListNew); + requirement = em.merge(requirement); + if (parentRequirementIdOld != null && !parentRequirementIdOld.equals(parentRequirementIdNew)) { + parentRequirementIdOld.getRequirementList().remove(requirement); + parentRequirementIdOld = em.merge(parentRequirementIdOld); + } + if (parentRequirementIdNew != null && !parentRequirementIdNew.equals(parentRequirementIdOld)) { + parentRequirementIdNew.getRequirementList().add(requirement); + parentRequirementIdNew = em.merge(parentRequirementIdNew); + } + if (requirementSpecNodeOld != null && !requirementSpecNodeOld.equals(requirementSpecNodeNew)) { + requirementSpecNodeOld.getRequirementList().remove(requirement); + requirementSpecNodeOld = em.merge(requirementSpecNodeOld); + } + if (requirementSpecNodeNew != null && !requirementSpecNodeNew.equals(requirementSpecNodeOld)) { + requirementSpecNodeNew.getRequirementList().add(requirement); + requirementSpecNodeNew = em.merge(requirementSpecNodeNew); + } + if (requirementStatusIdOld != null && !requirementStatusIdOld.equals(requirementStatusIdNew)) { + requirementStatusIdOld.getRequirementList().remove(requirement); + requirementStatusIdOld = em.merge(requirementStatusIdOld); + } + if (requirementStatusIdNew != null && !requirementStatusIdNew.equals(requirementStatusIdOld)) { + requirementStatusIdNew.getRequirementList().add(requirement); + requirementStatusIdNew = em.merge(requirementStatusIdNew); + } + if (requirementTypeIdOld != null && !requirementTypeIdOld.equals(requirementTypeIdNew)) { + requirementTypeIdOld.getRequirementList().remove(requirement); + requirementTypeIdOld = em.merge(requirementTypeIdOld); + } + if (requirementTypeIdNew != null && !requirementTypeIdNew.equals(requirementTypeIdOld)) { + requirementTypeIdNew.getRequirementList().add(requirement); + requirementTypeIdNew = em.merge(requirementTypeIdNew); + } + for (Requirement requirementListOldRequirement : requirementListOld) { + if (!requirementListNew.contains(requirementListOldRequirement)) { + requirementListOldRequirement.setParentRequirementId(null); + requirementListOldRequirement = em.merge(requirementListOldRequirement); + } + } + for (Requirement requirementListNewRequirement : requirementListNew) { + if (!requirementListOld.contains(requirementListNewRequirement)) { + Requirement oldParentRequirementIdOfRequirementListNewRequirement = requirementListNewRequirement.getParentRequirementId(); + requirementListNewRequirement.setParentRequirementId(requirement); + requirementListNewRequirement = em.merge(requirementListNewRequirement); + if (oldParentRequirementIdOfRequirementListNewRequirement != null && !oldParentRequirementIdOfRequirementListNewRequirement.equals(requirement)) { + oldParentRequirementIdOfRequirementListNewRequirement.getRequirementList().remove(requirementListNewRequirement); + oldParentRequirementIdOfRequirementListNewRequirement = em.merge(oldParentRequirementIdOfRequirementListNewRequirement); + } + } + } + for (Step stepListOldStep : stepListOld) { + if (!stepListNew.contains(stepListOldStep)) { + stepListOldStep.getRequirementList().remove(requirement); + stepListOldStep = em.merge(stepListOldStep); + } + } + for (Step stepListNewStep : stepListNew) { + if (!stepListOld.contains(stepListNewStep)) { + stepListNewStep.getRequirementList().add(requirement); + stepListNewStep = em.merge(stepListNewStep); + } + } + for (RiskControlHasRequirement riskControlHasRequirementListNewRiskControlHasRequirement : riskControlHasRequirementListNew) { + if (!riskControlHasRequirementListOld.contains(riskControlHasRequirementListNewRiskControlHasRequirement)) { + Requirement oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement = riskControlHasRequirementListNewRiskControlHasRequirement.getRequirement(); + riskControlHasRequirementListNewRiskControlHasRequirement.setRequirement(requirement); + riskControlHasRequirementListNewRiskControlHasRequirement = em.merge(riskControlHasRequirementListNewRiskControlHasRequirement); + if (oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement != null && !oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement.equals(requirement)) { + oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement.getRiskControlHasRequirementList().remove(riskControlHasRequirementListNewRiskControlHasRequirement); + oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement = em.merge(oldRequirementOfRiskControlHasRequirementListNewRiskControlHasRequirement); + } + } + } + for (History historyListOldHistory : historyListOld) { + if (!historyListNew.contains(historyListOldHistory)) { + historyListOldHistory.setRequirementId(null); + historyListOldHistory = em.merge(historyListOldHistory); + } + } + for (History historyListNewHistory : historyListNew) { + if (!historyListOld.contains(historyListNewHistory)) { + Requirement oldRequirementIdOfHistoryListNewHistory = historyListNewHistory.getRequirementId(); + historyListNewHistory.setRequirementId(requirement); + historyListNewHistory = em.merge(historyListNewHistory); + if (oldRequirementIdOfHistoryListNewHistory != null && !oldRequirementIdOfHistoryListNewHistory.equals(requirement)) { + oldRequirementIdOfHistoryListNewHistory.getHistoryList().remove(historyListNewHistory); + oldRequirementIdOfHistoryListNewHistory = em.merge(oldRequirementIdOfHistoryListNewHistory); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = requirement.getId(); + if (findRequirement(id) == null) { + throw new NonexistentEntityException("The requirement with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Requirement requirement; + try { + requirement = em.getReference(Requirement.class, id); + requirement.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The requirement with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List riskControlHasRequirementListOrphanCheck = requirement.getRiskControlHasRequirementList(); + for (RiskControlHasRequirement riskControlHasRequirementListOrphanCheckRiskControlHasRequirement : riskControlHasRequirementListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Requirement (" + requirement + ") cannot be destroyed since the RiskControlHasRequirement " + riskControlHasRequirementListOrphanCheckRiskControlHasRequirement + " in its riskControlHasRequirementList field has a non-nullable requirement field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + Requirement parentRequirementId = requirement.getParentRequirementId(); + if (parentRequirementId != null) { + parentRequirementId.getRequirementList().remove(requirement); + parentRequirementId = em.merge(parentRequirementId); + } + RequirementSpecNode requirementSpecNode = requirement.getRequirementSpecNode(); + if (requirementSpecNode != null) { + requirementSpecNode.getRequirementList().remove(requirement); + requirementSpecNode = em.merge(requirementSpecNode); + } + RequirementStatus requirementStatusId = requirement.getRequirementStatusId(); + if (requirementStatusId != null) { + requirementStatusId.getRequirementList().remove(requirement); + requirementStatusId = em.merge(requirementStatusId); + } + RequirementType requirementTypeId = requirement.getRequirementTypeId(); + if (requirementTypeId != null) { + requirementTypeId.getRequirementList().remove(requirement); + requirementTypeId = em.merge(requirementTypeId); + } + List requirementList = requirement.getRequirementList(); + for (Requirement requirementListRequirement : requirementList) { + requirementListRequirement.setParentRequirementId(null); + requirementListRequirement = em.merge(requirementListRequirement); + } + List stepList = requirement.getStepList(); + for (Step stepListStep : stepList) { + stepListStep.getRequirementList().remove(requirement); + stepListStep = em.merge(stepListStep); + } + List historyList = requirement.getHistoryList(); + for (History historyListHistory : historyList) { + historyListHistory.setRequirementId(null); + historyListHistory = em.merge(historyListHistory); + } + em.remove(requirement); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRequirementEntities() { + return findRequirementEntities(true, -1, -1); + } + + public List findRequirementEntities(int maxResults, int firstResult) { + return findRequirementEntities(false, maxResults, firstResult); + } + + private List findRequirementEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(Requirement.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public Requirement findRequirement(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(Requirement.class, id); + } + finally { + em.close(); + } + } + + public int getRequirementCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(Requirement.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementSpecJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementSpecJpaController.java index bcb1d522..47160912 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementSpecJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementSpecJpaController.java @@ -13,336 +13,336 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Project; -import com.validation.manager.core.db.SpecLevel; -import com.validation.manager.core.db.RequirementSpecNode; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.Baseline; -import com.validation.manager.core.db.RequirementSpec; -import com.validation.manager.core.db.RequirementSpecPK; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RequirementSpecJpaController implements Serializable { - - public RequirementSpecJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(RequirementSpec requirementSpec) throws PreexistingEntityException, Exception { - if (requirementSpec.getRequirementSpecPK() == null) { - requirementSpec.setRequirementSpecPK(new RequirementSpecPK()); - } - if (requirementSpec.getRequirementSpecNodeList() == null) { - requirementSpec.setRequirementSpecNodeList(new ArrayList()); - } - if (requirementSpec.getBaselineList() == null) { - requirementSpec.setBaselineList(new ArrayList()); - } - requirementSpec.getRequirementSpecPK().setSpecLevelId(requirementSpec.getSpecLevel().getId()); - requirementSpec.getRequirementSpecPK().setProjectId(requirementSpec.getProject().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Project project = requirementSpec.getProject(); - if (project != null) { - project = em.getReference(project.getClass(), project.getId()); - requirementSpec.setProject(project); - } - SpecLevel specLevel = requirementSpec.getSpecLevel(); - if (specLevel != null) { - specLevel = em.getReference(specLevel.getClass(), specLevel.getId()); - requirementSpec.setSpecLevel(specLevel); - } - List attachedRequirementSpecNodeList = new ArrayList(); - for (RequirementSpecNode requirementSpecNodeListRequirementSpecNodeToAttach : requirementSpec.getRequirementSpecNodeList()) { - requirementSpecNodeListRequirementSpecNodeToAttach = em.getReference(requirementSpecNodeListRequirementSpecNodeToAttach.getClass(), requirementSpecNodeListRequirementSpecNodeToAttach.getRequirementSpecNodePK()); - attachedRequirementSpecNodeList.add(requirementSpecNodeListRequirementSpecNodeToAttach); - } - requirementSpec.setRequirementSpecNodeList(attachedRequirementSpecNodeList); - List attachedBaselineList = new ArrayList(); - for (Baseline baselineListBaselineToAttach : requirementSpec.getBaselineList()) { - baselineListBaselineToAttach = em.getReference(baselineListBaselineToAttach.getClass(), baselineListBaselineToAttach.getId()); - attachedBaselineList.add(baselineListBaselineToAttach); - } - requirementSpec.setBaselineList(attachedBaselineList); - em.persist(requirementSpec); - if (project != null) { - project.getRequirementSpecList().add(requirementSpec); - project = em.merge(project); - } - if (specLevel != null) { - specLevel.getRequirementSpecList().add(requirementSpec); - specLevel = em.merge(specLevel); - } - for (RequirementSpecNode requirementSpecNodeListRequirementSpecNode : requirementSpec.getRequirementSpecNodeList()) { - RequirementSpec oldRequirementSpecOfRequirementSpecNodeListRequirementSpecNode = requirementSpecNodeListRequirementSpecNode.getRequirementSpec(); - requirementSpecNodeListRequirementSpecNode.setRequirementSpec(requirementSpec); - requirementSpecNodeListRequirementSpecNode = em.merge(requirementSpecNodeListRequirementSpecNode); - if (oldRequirementSpecOfRequirementSpecNodeListRequirementSpecNode != null) { - oldRequirementSpecOfRequirementSpecNodeListRequirementSpecNode.getRequirementSpecNodeList().remove(requirementSpecNodeListRequirementSpecNode); - oldRequirementSpecOfRequirementSpecNodeListRequirementSpecNode = em.merge(oldRequirementSpecOfRequirementSpecNodeListRequirementSpecNode); - } - } - for (Baseline baselineListBaseline : requirementSpec.getBaselineList()) { - RequirementSpec oldRequirementSpecOfBaselineListBaseline = baselineListBaseline.getRequirementSpec(); - baselineListBaseline.setRequirementSpec(requirementSpec); - baselineListBaseline = em.merge(baselineListBaseline); - if (oldRequirementSpecOfBaselineListBaseline != null) { - oldRequirementSpecOfBaselineListBaseline.getBaselineList().remove(baselineListBaseline); - oldRequirementSpecOfBaselineListBaseline = em.merge(oldRequirementSpecOfBaselineListBaseline); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findRequirementSpec(requirementSpec.getRequirementSpecPK()) != null) { - throw new PreexistingEntityException("RequirementSpec " + requirementSpec + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(RequirementSpec requirementSpec) throws IllegalOrphanException, NonexistentEntityException, Exception { - requirementSpec.getRequirementSpecPK().setSpecLevelId(requirementSpec.getSpecLevel().getId()); - requirementSpec.getRequirementSpecPK().setProjectId(requirementSpec.getProject().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RequirementSpec persistentRequirementSpec = em.find(RequirementSpec.class, requirementSpec.getRequirementSpecPK()); - Project projectOld = persistentRequirementSpec.getProject(); - Project projectNew = requirementSpec.getProject(); - SpecLevel specLevelOld = persistentRequirementSpec.getSpecLevel(); - SpecLevel specLevelNew = requirementSpec.getSpecLevel(); - List requirementSpecNodeListOld = persistentRequirementSpec.getRequirementSpecNodeList(); - List requirementSpecNodeListNew = requirementSpec.getRequirementSpecNodeList(); - List baselineListOld = persistentRequirementSpec.getBaselineList(); - List baselineListNew = requirementSpec.getBaselineList(); - List illegalOrphanMessages = null; - for (RequirementSpecNode requirementSpecNodeListOldRequirementSpecNode : requirementSpecNodeListOld) { - if (!requirementSpecNodeListNew.contains(requirementSpecNodeListOldRequirementSpecNode)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RequirementSpecNode " + requirementSpecNodeListOldRequirementSpecNode + " since its requirementSpec field is not nullable."); - } - } - for (Baseline baselineListOldBaseline : baselineListOld) { - if (!baselineListNew.contains(baselineListOldBaseline)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain Baseline " + baselineListOldBaseline + " since its requirementSpec field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (projectNew != null) { - projectNew = em.getReference(projectNew.getClass(), projectNew.getId()); - requirementSpec.setProject(projectNew); - } - if (specLevelNew != null) { - specLevelNew = em.getReference(specLevelNew.getClass(), specLevelNew.getId()); - requirementSpec.setSpecLevel(specLevelNew); - } - List attachedRequirementSpecNodeListNew = new ArrayList(); - for (RequirementSpecNode requirementSpecNodeListNewRequirementSpecNodeToAttach : requirementSpecNodeListNew) { - requirementSpecNodeListNewRequirementSpecNodeToAttach = em.getReference(requirementSpecNodeListNewRequirementSpecNodeToAttach.getClass(), requirementSpecNodeListNewRequirementSpecNodeToAttach.getRequirementSpecNodePK()); - attachedRequirementSpecNodeListNew.add(requirementSpecNodeListNewRequirementSpecNodeToAttach); - } - requirementSpecNodeListNew = attachedRequirementSpecNodeListNew; - requirementSpec.setRequirementSpecNodeList(requirementSpecNodeListNew); - List attachedBaselineListNew = new ArrayList(); - for (Baseline baselineListNewBaselineToAttach : baselineListNew) { - baselineListNewBaselineToAttach = em.getReference(baselineListNewBaselineToAttach.getClass(), baselineListNewBaselineToAttach.getId()); - attachedBaselineListNew.add(baselineListNewBaselineToAttach); - } - baselineListNew = attachedBaselineListNew; - requirementSpec.setBaselineList(baselineListNew); - requirementSpec = em.merge(requirementSpec); - if (projectOld != null && !projectOld.equals(projectNew)) { - projectOld.getRequirementSpecList().remove(requirementSpec); - projectOld = em.merge(projectOld); - } - if (projectNew != null && !projectNew.equals(projectOld)) { - projectNew.getRequirementSpecList().add(requirementSpec); - projectNew = em.merge(projectNew); - } - if (specLevelOld != null && !specLevelOld.equals(specLevelNew)) { - specLevelOld.getRequirementSpecList().remove(requirementSpec); - specLevelOld = em.merge(specLevelOld); - } - if (specLevelNew != null && !specLevelNew.equals(specLevelOld)) { - specLevelNew.getRequirementSpecList().add(requirementSpec); - specLevelNew = em.merge(specLevelNew); - } - for (RequirementSpecNode requirementSpecNodeListNewRequirementSpecNode : requirementSpecNodeListNew) { - if (!requirementSpecNodeListOld.contains(requirementSpecNodeListNewRequirementSpecNode)) { - RequirementSpec oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode = requirementSpecNodeListNewRequirementSpecNode.getRequirementSpec(); - requirementSpecNodeListNewRequirementSpecNode.setRequirementSpec(requirementSpec); - requirementSpecNodeListNewRequirementSpecNode = em.merge(requirementSpecNodeListNewRequirementSpecNode); - if (oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode != null && !oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode.equals(requirementSpec)) { - oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode.getRequirementSpecNodeList().remove(requirementSpecNodeListNewRequirementSpecNode); - oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode = em.merge(oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode); - } - } - } - for (Baseline baselineListNewBaseline : baselineListNew) { - if (!baselineListOld.contains(baselineListNewBaseline)) { - RequirementSpec oldRequirementSpecOfBaselineListNewBaseline = baselineListNewBaseline.getRequirementSpec(); - baselineListNewBaseline.setRequirementSpec(requirementSpec); - baselineListNewBaseline = em.merge(baselineListNewBaseline); - if (oldRequirementSpecOfBaselineListNewBaseline != null && !oldRequirementSpecOfBaselineListNewBaseline.equals(requirementSpec)) { - oldRequirementSpecOfBaselineListNewBaseline.getBaselineList().remove(baselineListNewBaseline); - oldRequirementSpecOfBaselineListNewBaseline = em.merge(oldRequirementSpecOfBaselineListNewBaseline); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - RequirementSpecPK id = requirementSpec.getRequirementSpecPK(); - if (findRequirementSpec(id) == null) { - throw new NonexistentEntityException("The requirementSpec with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(RequirementSpecPK id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RequirementSpec requirementSpec; - try { - requirementSpec = em.getReference(RequirementSpec.class, id); - requirementSpec.getRequirementSpecPK(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The requirementSpec with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List requirementSpecNodeListOrphanCheck = requirementSpec.getRequirementSpecNodeList(); - for (RequirementSpecNode requirementSpecNodeListOrphanCheckRequirementSpecNode : requirementSpecNodeListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RequirementSpec (" + requirementSpec + ") cannot be destroyed since the RequirementSpecNode " + requirementSpecNodeListOrphanCheckRequirementSpecNode + " in its requirementSpecNodeList field has a non-nullable requirementSpec field."); - } - List baselineListOrphanCheck = requirementSpec.getBaselineList(); - for (Baseline baselineListOrphanCheckBaseline : baselineListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RequirementSpec (" + requirementSpec + ") cannot be destroyed since the Baseline " + baselineListOrphanCheckBaseline + " in its baselineList field has a non-nullable requirementSpec field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - Project project = requirementSpec.getProject(); - if (project != null) { - project.getRequirementSpecList().remove(requirementSpec); - project = em.merge(project); - } - SpecLevel specLevel = requirementSpec.getSpecLevel(); - if (specLevel != null) { - specLevel.getRequirementSpecList().remove(requirementSpec); - specLevel = em.merge(specLevel); - } - em.remove(requirementSpec); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRequirementSpecEntities() { - return findRequirementSpecEntities(true, -1, -1); - } - - public List findRequirementSpecEntities(int maxResults, int firstResult) { - return findRequirementSpecEntities(false, maxResults, firstResult); - } - - private List findRequirementSpecEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(RequirementSpec.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public RequirementSpec findRequirementSpec(RequirementSpecPK id) { - EntityManager em = getEntityManager(); - try { - return em.find(RequirementSpec.class, id); - } - finally { - em.close(); - } - } - - public int getRequirementSpecCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(RequirementSpec.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Project; +import com.validation.manager.core.db.SpecLevel; +import com.validation.manager.core.db.RequirementSpecNode; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.Baseline; +import com.validation.manager.core.db.RequirementSpec; +import com.validation.manager.core.db.RequirementSpecPK; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RequirementSpecJpaController implements Serializable { + + public RequirementSpecJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(RequirementSpec requirementSpec) throws PreexistingEntityException, Exception { + if (requirementSpec.getRequirementSpecPK() == null) { + requirementSpec.setRequirementSpecPK(new RequirementSpecPK()); + } + if (requirementSpec.getRequirementSpecNodeList() == null) { + requirementSpec.setRequirementSpecNodeList(new ArrayList<>()); + } + if (requirementSpec.getBaselineList() == null) { + requirementSpec.setBaselineList(new ArrayList<>()); + } + requirementSpec.getRequirementSpecPK().setSpecLevelId(requirementSpec.getSpecLevel().getId()); + requirementSpec.getRequirementSpecPK().setProjectId(requirementSpec.getProject().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Project project = requirementSpec.getProject(); + if (project != null) { + project = em.getReference(project.getClass(), project.getId()); + requirementSpec.setProject(project); + } + SpecLevel specLevel = requirementSpec.getSpecLevel(); + if (specLevel != null) { + specLevel = em.getReference(specLevel.getClass(), specLevel.getId()); + requirementSpec.setSpecLevel(specLevel); + } + List attachedRequirementSpecNodeList = new ArrayList<>(); + for (RequirementSpecNode requirementSpecNodeListRequirementSpecNodeToAttach : requirementSpec.getRequirementSpecNodeList()) { + requirementSpecNodeListRequirementSpecNodeToAttach = em.getReference(requirementSpecNodeListRequirementSpecNodeToAttach.getClass(), requirementSpecNodeListRequirementSpecNodeToAttach.getRequirementSpecNodePK()); + attachedRequirementSpecNodeList.add(requirementSpecNodeListRequirementSpecNodeToAttach); + } + requirementSpec.setRequirementSpecNodeList(attachedRequirementSpecNodeList); + List attachedBaselineList = new ArrayList<>(); + for (Baseline baselineListBaselineToAttach : requirementSpec.getBaselineList()) { + baselineListBaselineToAttach = em.getReference(baselineListBaselineToAttach.getClass(), baselineListBaselineToAttach.getId()); + attachedBaselineList.add(baselineListBaselineToAttach); + } + requirementSpec.setBaselineList(attachedBaselineList); + em.persist(requirementSpec); + if (project != null) { + project.getRequirementSpecList().add(requirementSpec); + project = em.merge(project); + } + if (specLevel != null) { + specLevel.getRequirementSpecList().add(requirementSpec); + specLevel = em.merge(specLevel); + } + for (RequirementSpecNode requirementSpecNodeListRequirementSpecNode : requirementSpec.getRequirementSpecNodeList()) { + RequirementSpec oldRequirementSpecOfRequirementSpecNodeListRequirementSpecNode = requirementSpecNodeListRequirementSpecNode.getRequirementSpec(); + requirementSpecNodeListRequirementSpecNode.setRequirementSpec(requirementSpec); + requirementSpecNodeListRequirementSpecNode = em.merge(requirementSpecNodeListRequirementSpecNode); + if (oldRequirementSpecOfRequirementSpecNodeListRequirementSpecNode != null) { + oldRequirementSpecOfRequirementSpecNodeListRequirementSpecNode.getRequirementSpecNodeList().remove(requirementSpecNodeListRequirementSpecNode); + oldRequirementSpecOfRequirementSpecNodeListRequirementSpecNode = em.merge(oldRequirementSpecOfRequirementSpecNodeListRequirementSpecNode); + } + } + for (Baseline baselineListBaseline : requirementSpec.getBaselineList()) { + RequirementSpec oldRequirementSpecOfBaselineListBaseline = baselineListBaseline.getRequirementSpec(); + baselineListBaseline.setRequirementSpec(requirementSpec); + baselineListBaseline = em.merge(baselineListBaseline); + if (oldRequirementSpecOfBaselineListBaseline != null) { + oldRequirementSpecOfBaselineListBaseline.getBaselineList().remove(baselineListBaseline); + oldRequirementSpecOfBaselineListBaseline = em.merge(oldRequirementSpecOfBaselineListBaseline); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findRequirementSpec(requirementSpec.getRequirementSpecPK()) != null) { + throw new PreexistingEntityException("RequirementSpec " + requirementSpec + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(RequirementSpec requirementSpec) throws IllegalOrphanException, NonexistentEntityException, Exception { + requirementSpec.getRequirementSpecPK().setSpecLevelId(requirementSpec.getSpecLevel().getId()); + requirementSpec.getRequirementSpecPK().setProjectId(requirementSpec.getProject().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RequirementSpec persistentRequirementSpec = em.find(RequirementSpec.class, requirementSpec.getRequirementSpecPK()); + Project projectOld = persistentRequirementSpec.getProject(); + Project projectNew = requirementSpec.getProject(); + SpecLevel specLevelOld = persistentRequirementSpec.getSpecLevel(); + SpecLevel specLevelNew = requirementSpec.getSpecLevel(); + List requirementSpecNodeListOld = persistentRequirementSpec.getRequirementSpecNodeList(); + List requirementSpecNodeListNew = requirementSpec.getRequirementSpecNodeList(); + List baselineListOld = persistentRequirementSpec.getBaselineList(); + List baselineListNew = requirementSpec.getBaselineList(); + List illegalOrphanMessages = null; + for (RequirementSpecNode requirementSpecNodeListOldRequirementSpecNode : requirementSpecNodeListOld) { + if (!requirementSpecNodeListNew.contains(requirementSpecNodeListOldRequirementSpecNode)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RequirementSpecNode " + requirementSpecNodeListOldRequirementSpecNode + " since its requirementSpec field is not nullable."); + } + } + for (Baseline baselineListOldBaseline : baselineListOld) { + if (!baselineListNew.contains(baselineListOldBaseline)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain Baseline " + baselineListOldBaseline + " since its requirementSpec field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (projectNew != null) { + projectNew = em.getReference(projectNew.getClass(), projectNew.getId()); + requirementSpec.setProject(projectNew); + } + if (specLevelNew != null) { + specLevelNew = em.getReference(specLevelNew.getClass(), specLevelNew.getId()); + requirementSpec.setSpecLevel(specLevelNew); + } + List attachedRequirementSpecNodeListNew = new ArrayList<>(); + for (RequirementSpecNode requirementSpecNodeListNewRequirementSpecNodeToAttach : requirementSpecNodeListNew) { + requirementSpecNodeListNewRequirementSpecNodeToAttach = em.getReference(requirementSpecNodeListNewRequirementSpecNodeToAttach.getClass(), requirementSpecNodeListNewRequirementSpecNodeToAttach.getRequirementSpecNodePK()); + attachedRequirementSpecNodeListNew.add(requirementSpecNodeListNewRequirementSpecNodeToAttach); + } + requirementSpecNodeListNew = attachedRequirementSpecNodeListNew; + requirementSpec.setRequirementSpecNodeList(requirementSpecNodeListNew); + List attachedBaselineListNew = new ArrayList<>(); + for (Baseline baselineListNewBaselineToAttach : baselineListNew) { + baselineListNewBaselineToAttach = em.getReference(baselineListNewBaselineToAttach.getClass(), baselineListNewBaselineToAttach.getId()); + attachedBaselineListNew.add(baselineListNewBaselineToAttach); + } + baselineListNew = attachedBaselineListNew; + requirementSpec.setBaselineList(baselineListNew); + requirementSpec = em.merge(requirementSpec); + if (projectOld != null && !projectOld.equals(projectNew)) { + projectOld.getRequirementSpecList().remove(requirementSpec); + projectOld = em.merge(projectOld); + } + if (projectNew != null && !projectNew.equals(projectOld)) { + projectNew.getRequirementSpecList().add(requirementSpec); + projectNew = em.merge(projectNew); + } + if (specLevelOld != null && !specLevelOld.equals(specLevelNew)) { + specLevelOld.getRequirementSpecList().remove(requirementSpec); + specLevelOld = em.merge(specLevelOld); + } + if (specLevelNew != null && !specLevelNew.equals(specLevelOld)) { + specLevelNew.getRequirementSpecList().add(requirementSpec); + specLevelNew = em.merge(specLevelNew); + } + for (RequirementSpecNode requirementSpecNodeListNewRequirementSpecNode : requirementSpecNodeListNew) { + if (!requirementSpecNodeListOld.contains(requirementSpecNodeListNewRequirementSpecNode)) { + RequirementSpec oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode = requirementSpecNodeListNewRequirementSpecNode.getRequirementSpec(); + requirementSpecNodeListNewRequirementSpecNode.setRequirementSpec(requirementSpec); + requirementSpecNodeListNewRequirementSpecNode = em.merge(requirementSpecNodeListNewRequirementSpecNode); + if (oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode != null && !oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode.equals(requirementSpec)) { + oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode.getRequirementSpecNodeList().remove(requirementSpecNodeListNewRequirementSpecNode); + oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode = em.merge(oldRequirementSpecOfRequirementSpecNodeListNewRequirementSpecNode); + } + } + } + for (Baseline baselineListNewBaseline : baselineListNew) { + if (!baselineListOld.contains(baselineListNewBaseline)) { + RequirementSpec oldRequirementSpecOfBaselineListNewBaseline = baselineListNewBaseline.getRequirementSpec(); + baselineListNewBaseline.setRequirementSpec(requirementSpec); + baselineListNewBaseline = em.merge(baselineListNewBaseline); + if (oldRequirementSpecOfBaselineListNewBaseline != null && !oldRequirementSpecOfBaselineListNewBaseline.equals(requirementSpec)) { + oldRequirementSpecOfBaselineListNewBaseline.getBaselineList().remove(baselineListNewBaseline); + oldRequirementSpecOfBaselineListNewBaseline = em.merge(oldRequirementSpecOfBaselineListNewBaseline); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + RequirementSpecPK id = requirementSpec.getRequirementSpecPK(); + if (findRequirementSpec(id) == null) { + throw new NonexistentEntityException("The requirementSpec with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(RequirementSpecPK id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RequirementSpec requirementSpec; + try { + requirementSpec = em.getReference(RequirementSpec.class, id); + requirementSpec.getRequirementSpecPK(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The requirementSpec with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List requirementSpecNodeListOrphanCheck = requirementSpec.getRequirementSpecNodeList(); + for (RequirementSpecNode requirementSpecNodeListOrphanCheckRequirementSpecNode : requirementSpecNodeListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RequirementSpec (" + requirementSpec + ") cannot be destroyed since the RequirementSpecNode " + requirementSpecNodeListOrphanCheckRequirementSpecNode + " in its requirementSpecNodeList field has a non-nullable requirementSpec field."); + } + List baselineListOrphanCheck = requirementSpec.getBaselineList(); + for (Baseline baselineListOrphanCheckBaseline : baselineListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RequirementSpec (" + requirementSpec + ") cannot be destroyed since the Baseline " + baselineListOrphanCheckBaseline + " in its baselineList field has a non-nullable requirementSpec field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + Project project = requirementSpec.getProject(); + if (project != null) { + project.getRequirementSpecList().remove(requirementSpec); + project = em.merge(project); + } + SpecLevel specLevel = requirementSpec.getSpecLevel(); + if (specLevel != null) { + specLevel.getRequirementSpecList().remove(requirementSpec); + specLevel = em.merge(specLevel); + } + em.remove(requirementSpec); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRequirementSpecEntities() { + return findRequirementSpecEntities(true, -1, -1); + } + + public List findRequirementSpecEntities(int maxResults, int firstResult) { + return findRequirementSpecEntities(false, maxResults, firstResult); + } + + private List findRequirementSpecEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(RequirementSpec.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public RequirementSpec findRequirementSpec(RequirementSpecPK id) { + EntityManager em = getEntityManager(); + try { + return em.find(RequirementSpec.class, id); + } + finally { + em.close(); + } + } + + public int getRequirementSpecCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(RequirementSpec.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementSpecNodeJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementSpecNodeJpaController.java index bb85a9ad..07511bb7 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementSpecNodeJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementSpecNodeJpaController.java @@ -13,332 +13,332 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.RequirementSpec; -import com.validation.manager.core.db.RequirementSpecNode; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.Requirement; -import com.validation.manager.core.db.RequirementSpecNodePK; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RequirementSpecNodeJpaController implements Serializable { - - public RequirementSpecNodeJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(RequirementSpecNode requirementSpecNode) throws PreexistingEntityException, Exception { - if (requirementSpecNode.getRequirementSpecNodePK() == null) { - requirementSpecNode.setRequirementSpecNodePK(new RequirementSpecNodePK()); - } - if (requirementSpecNode.getRequirementSpecNodeList() == null) { - requirementSpecNode.setRequirementSpecNodeList(new ArrayList()); - } - if (requirementSpecNode.getRequirementList() == null) { - requirementSpecNode.setRequirementList(new ArrayList()); - } - requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getId()); - requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecProjectId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getProjectId()); - requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecSpecLevelId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getSpecLevelId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RequirementSpec requirementSpec = requirementSpecNode.getRequirementSpec(); - if (requirementSpec != null) { - requirementSpec = em.getReference(requirementSpec.getClass(), requirementSpec.getRequirementSpecPK()); - requirementSpecNode.setRequirementSpec(requirementSpec); - } - RequirementSpecNode requirementSpecNodeRel = requirementSpecNode.getRequirementSpecNode(); - if (requirementSpecNodeRel != null) { - requirementSpecNodeRel = em.getReference(requirementSpecNodeRel.getClass(), requirementSpecNodeRel.getRequirementSpecNodePK()); - requirementSpecNode.setRequirementSpecNode(requirementSpecNodeRel); - } - List attachedRequirementSpecNodeList = new ArrayList(); - for (RequirementSpecNode requirementSpecNodeListRequirementSpecNodeToAttach : requirementSpecNode.getRequirementSpecNodeList()) { - requirementSpecNodeListRequirementSpecNodeToAttach = em.getReference(requirementSpecNodeListRequirementSpecNodeToAttach.getClass(), requirementSpecNodeListRequirementSpecNodeToAttach.getRequirementSpecNodePK()); - attachedRequirementSpecNodeList.add(requirementSpecNodeListRequirementSpecNodeToAttach); - } - requirementSpecNode.setRequirementSpecNodeList(attachedRequirementSpecNodeList); - List attachedRequirementList = new ArrayList(); - for (Requirement requirementListRequirementToAttach : requirementSpecNode.getRequirementList()) { - requirementListRequirementToAttach = em.getReference(requirementListRequirementToAttach.getClass(), requirementListRequirementToAttach.getId()); - attachedRequirementList.add(requirementListRequirementToAttach); - } - requirementSpecNode.setRequirementList(attachedRequirementList); - em.persist(requirementSpecNode); - if (requirementSpec != null) { - requirementSpec.getRequirementSpecNodeList().add(requirementSpecNode); - requirementSpec = em.merge(requirementSpec); - } - if (requirementSpecNodeRel != null) { - requirementSpecNodeRel.getRequirementSpecNodeList().add(requirementSpecNode); - requirementSpecNodeRel = em.merge(requirementSpecNodeRel); - } - for (RequirementSpecNode requirementSpecNodeListRequirementSpecNode : requirementSpecNode.getRequirementSpecNodeList()) { - RequirementSpecNode oldRequirementSpecNodeOfRequirementSpecNodeListRequirementSpecNode = requirementSpecNodeListRequirementSpecNode.getRequirementSpecNode(); - requirementSpecNodeListRequirementSpecNode.setRequirementSpecNode(requirementSpecNode); - requirementSpecNodeListRequirementSpecNode = em.merge(requirementSpecNodeListRequirementSpecNode); - if (oldRequirementSpecNodeOfRequirementSpecNodeListRequirementSpecNode != null) { - oldRequirementSpecNodeOfRequirementSpecNodeListRequirementSpecNode.getRequirementSpecNodeList().remove(requirementSpecNodeListRequirementSpecNode); - oldRequirementSpecNodeOfRequirementSpecNodeListRequirementSpecNode = em.merge(oldRequirementSpecNodeOfRequirementSpecNodeListRequirementSpecNode); - } - } - for (Requirement requirementListRequirement : requirementSpecNode.getRequirementList()) { - RequirementSpecNode oldRequirementSpecNodeOfRequirementListRequirement = requirementListRequirement.getRequirementSpecNode(); - requirementListRequirement.setRequirementSpecNode(requirementSpecNode); - requirementListRequirement = em.merge(requirementListRequirement); - if (oldRequirementSpecNodeOfRequirementListRequirement != null) { - oldRequirementSpecNodeOfRequirementListRequirement.getRequirementList().remove(requirementListRequirement); - oldRequirementSpecNodeOfRequirementListRequirement = em.merge(oldRequirementSpecNodeOfRequirementListRequirement); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findRequirementSpecNode(requirementSpecNode.getRequirementSpecNodePK()) != null) { - throw new PreexistingEntityException("RequirementSpecNode " + requirementSpecNode + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(RequirementSpecNode requirementSpecNode) throws IllegalOrphanException, NonexistentEntityException, Exception { - requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getId()); - requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecProjectId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getProjectId()); - requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecSpecLevelId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getSpecLevelId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RequirementSpecNode persistentRequirementSpecNode = em.find(RequirementSpecNode.class, requirementSpecNode.getRequirementSpecNodePK()); - RequirementSpec requirementSpecOld = persistentRequirementSpecNode.getRequirementSpec(); - RequirementSpec requirementSpecNew = requirementSpecNode.getRequirementSpec(); - RequirementSpecNode requirementSpecNodeRelOld = persistentRequirementSpecNode.getRequirementSpecNode(); - RequirementSpecNode requirementSpecNodeRelNew = requirementSpecNode.getRequirementSpecNode(); - List requirementSpecNodeListOld = persistentRequirementSpecNode.getRequirementSpecNodeList(); - List requirementSpecNodeListNew = requirementSpecNode.getRequirementSpecNodeList(); - List requirementListOld = persistentRequirementSpecNode.getRequirementList(); - List requirementListNew = requirementSpecNode.getRequirementList(); - List illegalOrphanMessages = null; - for (Requirement requirementListOldRequirement : requirementListOld) { - if (!requirementListNew.contains(requirementListOldRequirement)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain Requirement " + requirementListOldRequirement + " since its requirementSpecNode field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (requirementSpecNew != null) { - requirementSpecNew = em.getReference(requirementSpecNew.getClass(), requirementSpecNew.getRequirementSpecPK()); - requirementSpecNode.setRequirementSpec(requirementSpecNew); - } - if (requirementSpecNodeRelNew != null) { - requirementSpecNodeRelNew = em.getReference(requirementSpecNodeRelNew.getClass(), requirementSpecNodeRelNew.getRequirementSpecNodePK()); - requirementSpecNode.setRequirementSpecNode(requirementSpecNodeRelNew); - } - List attachedRequirementSpecNodeListNew = new ArrayList(); - for (RequirementSpecNode requirementSpecNodeListNewRequirementSpecNodeToAttach : requirementSpecNodeListNew) { - requirementSpecNodeListNewRequirementSpecNodeToAttach = em.getReference(requirementSpecNodeListNewRequirementSpecNodeToAttach.getClass(), requirementSpecNodeListNewRequirementSpecNodeToAttach.getRequirementSpecNodePK()); - attachedRequirementSpecNodeListNew.add(requirementSpecNodeListNewRequirementSpecNodeToAttach); - } - requirementSpecNodeListNew = attachedRequirementSpecNodeListNew; - requirementSpecNode.setRequirementSpecNodeList(requirementSpecNodeListNew); - List attachedRequirementListNew = new ArrayList(); - for (Requirement requirementListNewRequirementToAttach : requirementListNew) { - requirementListNewRequirementToAttach = em.getReference(requirementListNewRequirementToAttach.getClass(), requirementListNewRequirementToAttach.getId()); - attachedRequirementListNew.add(requirementListNewRequirementToAttach); - } - requirementListNew = attachedRequirementListNew; - requirementSpecNode.setRequirementList(requirementListNew); - requirementSpecNode = em.merge(requirementSpecNode); - if (requirementSpecOld != null && !requirementSpecOld.equals(requirementSpecNew)) { - requirementSpecOld.getRequirementSpecNodeList().remove(requirementSpecNode); - requirementSpecOld = em.merge(requirementSpecOld); - } - if (requirementSpecNew != null && !requirementSpecNew.equals(requirementSpecOld)) { - requirementSpecNew.getRequirementSpecNodeList().add(requirementSpecNode); - requirementSpecNew = em.merge(requirementSpecNew); - } - if (requirementSpecNodeRelOld != null && !requirementSpecNodeRelOld.equals(requirementSpecNodeRelNew)) { - requirementSpecNodeRelOld.getRequirementSpecNodeList().remove(requirementSpecNode); - requirementSpecNodeRelOld = em.merge(requirementSpecNodeRelOld); - } - if (requirementSpecNodeRelNew != null && !requirementSpecNodeRelNew.equals(requirementSpecNodeRelOld)) { - requirementSpecNodeRelNew.getRequirementSpecNodeList().add(requirementSpecNode); - requirementSpecNodeRelNew = em.merge(requirementSpecNodeRelNew); - } - for (RequirementSpecNode requirementSpecNodeListOldRequirementSpecNode : requirementSpecNodeListOld) { - if (!requirementSpecNodeListNew.contains(requirementSpecNodeListOldRequirementSpecNode)) { - requirementSpecNodeListOldRequirementSpecNode.setRequirementSpecNode(null); - requirementSpecNodeListOldRequirementSpecNode = em.merge(requirementSpecNodeListOldRequirementSpecNode); - } - } - for (RequirementSpecNode requirementSpecNodeListNewRequirementSpecNode : requirementSpecNodeListNew) { - if (!requirementSpecNodeListOld.contains(requirementSpecNodeListNewRequirementSpecNode)) { - RequirementSpecNode oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode = requirementSpecNodeListNewRequirementSpecNode.getRequirementSpecNode(); - requirementSpecNodeListNewRequirementSpecNode.setRequirementSpecNode(requirementSpecNode); - requirementSpecNodeListNewRequirementSpecNode = em.merge(requirementSpecNodeListNewRequirementSpecNode); - if (oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode != null && !oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode.equals(requirementSpecNode)) { - oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode.getRequirementSpecNodeList().remove(requirementSpecNodeListNewRequirementSpecNode); - oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode = em.merge(oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode); - } - } - } - for (Requirement requirementListNewRequirement : requirementListNew) { - if (!requirementListOld.contains(requirementListNewRequirement)) { - RequirementSpecNode oldRequirementSpecNodeOfRequirementListNewRequirement = requirementListNewRequirement.getRequirementSpecNode(); - requirementListNewRequirement.setRequirementSpecNode(requirementSpecNode); - requirementListNewRequirement = em.merge(requirementListNewRequirement); - if (oldRequirementSpecNodeOfRequirementListNewRequirement != null && !oldRequirementSpecNodeOfRequirementListNewRequirement.equals(requirementSpecNode)) { - oldRequirementSpecNodeOfRequirementListNewRequirement.getRequirementList().remove(requirementListNewRequirement); - oldRequirementSpecNodeOfRequirementListNewRequirement = em.merge(oldRequirementSpecNodeOfRequirementListNewRequirement); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - RequirementSpecNodePK id = requirementSpecNode.getRequirementSpecNodePK(); - if (findRequirementSpecNode(id) == null) { - throw new NonexistentEntityException("The requirementSpecNode with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(RequirementSpecNodePK id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RequirementSpecNode requirementSpecNode; - try { - requirementSpecNode = em.getReference(RequirementSpecNode.class, id); - requirementSpecNode.getRequirementSpecNodePK(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The requirementSpecNode with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List requirementListOrphanCheck = requirementSpecNode.getRequirementList(); - for (Requirement requirementListOrphanCheckRequirement : requirementListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RequirementSpecNode (" + requirementSpecNode + ") cannot be destroyed since the Requirement " + requirementListOrphanCheckRequirement + " in its requirementList field has a non-nullable requirementSpecNode field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - RequirementSpec requirementSpec = requirementSpecNode.getRequirementSpec(); - if (requirementSpec != null) { - requirementSpec.getRequirementSpecNodeList().remove(requirementSpecNode); - requirementSpec = em.merge(requirementSpec); - } - RequirementSpecNode requirementSpecNodeRel = requirementSpecNode.getRequirementSpecNode(); - if (requirementSpecNodeRel != null) { - requirementSpecNodeRel.getRequirementSpecNodeList().remove(requirementSpecNode); - requirementSpecNodeRel = em.merge(requirementSpecNodeRel); - } - List requirementSpecNodeList = requirementSpecNode.getRequirementSpecNodeList(); - for (RequirementSpecNode requirementSpecNodeListRequirementSpecNode : requirementSpecNodeList) { - requirementSpecNodeListRequirementSpecNode.setRequirementSpecNode(null); - requirementSpecNodeListRequirementSpecNode = em.merge(requirementSpecNodeListRequirementSpecNode); - } - em.remove(requirementSpecNode); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRequirementSpecNodeEntities() { - return findRequirementSpecNodeEntities(true, -1, -1); - } - - public List findRequirementSpecNodeEntities(int maxResults, int firstResult) { - return findRequirementSpecNodeEntities(false, maxResults, firstResult); - } - - private List findRequirementSpecNodeEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(RequirementSpecNode.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public RequirementSpecNode findRequirementSpecNode(RequirementSpecNodePK id) { - EntityManager em = getEntityManager(); - try { - return em.find(RequirementSpecNode.class, id); - } - finally { - em.close(); - } - } - - public int getRequirementSpecNodeCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(RequirementSpecNode.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.RequirementSpec; +import com.validation.manager.core.db.RequirementSpecNode; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.Requirement; +import com.validation.manager.core.db.RequirementSpecNodePK; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RequirementSpecNodeJpaController implements Serializable { + + public RequirementSpecNodeJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(RequirementSpecNode requirementSpecNode) throws PreexistingEntityException, Exception { + if (requirementSpecNode.getRequirementSpecNodePK() == null) { + requirementSpecNode.setRequirementSpecNodePK(new RequirementSpecNodePK()); + } + if (requirementSpecNode.getRequirementSpecNodeList() == null) { + requirementSpecNode.setRequirementSpecNodeList(new ArrayList<>()); + } + if (requirementSpecNode.getRequirementList() == null) { + requirementSpecNode.setRequirementList(new ArrayList<>()); + } + requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getId()); + requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecProjectId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getProjectId()); + requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecSpecLevelId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getSpecLevelId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RequirementSpec requirementSpec = requirementSpecNode.getRequirementSpec(); + if (requirementSpec != null) { + requirementSpec = em.getReference(requirementSpec.getClass(), requirementSpec.getRequirementSpecPK()); + requirementSpecNode.setRequirementSpec(requirementSpec); + } + RequirementSpecNode requirementSpecNodeRel = requirementSpecNode.getRequirementSpecNode(); + if (requirementSpecNodeRel != null) { + requirementSpecNodeRel = em.getReference(requirementSpecNodeRel.getClass(), requirementSpecNodeRel.getRequirementSpecNodePK()); + requirementSpecNode.setRequirementSpecNode(requirementSpecNodeRel); + } + List attachedRequirementSpecNodeList = new ArrayList<>(); + for (RequirementSpecNode requirementSpecNodeListRequirementSpecNodeToAttach : requirementSpecNode.getRequirementSpecNodeList()) { + requirementSpecNodeListRequirementSpecNodeToAttach = em.getReference(requirementSpecNodeListRequirementSpecNodeToAttach.getClass(), requirementSpecNodeListRequirementSpecNodeToAttach.getRequirementSpecNodePK()); + attachedRequirementSpecNodeList.add(requirementSpecNodeListRequirementSpecNodeToAttach); + } + requirementSpecNode.setRequirementSpecNodeList(attachedRequirementSpecNodeList); + List attachedRequirementList = new ArrayList<>(); + for (Requirement requirementListRequirementToAttach : requirementSpecNode.getRequirementList()) { + requirementListRequirementToAttach = em.getReference(requirementListRequirementToAttach.getClass(), requirementListRequirementToAttach.getId()); + attachedRequirementList.add(requirementListRequirementToAttach); + } + requirementSpecNode.setRequirementList(attachedRequirementList); + em.persist(requirementSpecNode); + if (requirementSpec != null) { + requirementSpec.getRequirementSpecNodeList().add(requirementSpecNode); + requirementSpec = em.merge(requirementSpec); + } + if (requirementSpecNodeRel != null) { + requirementSpecNodeRel.getRequirementSpecNodeList().add(requirementSpecNode); + requirementSpecNodeRel = em.merge(requirementSpecNodeRel); + } + for (RequirementSpecNode requirementSpecNodeListRequirementSpecNode : requirementSpecNode.getRequirementSpecNodeList()) { + RequirementSpecNode oldRequirementSpecNodeOfRequirementSpecNodeListRequirementSpecNode = requirementSpecNodeListRequirementSpecNode.getRequirementSpecNode(); + requirementSpecNodeListRequirementSpecNode.setRequirementSpecNode(requirementSpecNode); + requirementSpecNodeListRequirementSpecNode = em.merge(requirementSpecNodeListRequirementSpecNode); + if (oldRequirementSpecNodeOfRequirementSpecNodeListRequirementSpecNode != null) { + oldRequirementSpecNodeOfRequirementSpecNodeListRequirementSpecNode.getRequirementSpecNodeList().remove(requirementSpecNodeListRequirementSpecNode); + oldRequirementSpecNodeOfRequirementSpecNodeListRequirementSpecNode = em.merge(oldRequirementSpecNodeOfRequirementSpecNodeListRequirementSpecNode); + } + } + for (Requirement requirementListRequirement : requirementSpecNode.getRequirementList()) { + RequirementSpecNode oldRequirementSpecNodeOfRequirementListRequirement = requirementListRequirement.getRequirementSpecNode(); + requirementListRequirement.setRequirementSpecNode(requirementSpecNode); + requirementListRequirement = em.merge(requirementListRequirement); + if (oldRequirementSpecNodeOfRequirementListRequirement != null) { + oldRequirementSpecNodeOfRequirementListRequirement.getRequirementList().remove(requirementListRequirement); + oldRequirementSpecNodeOfRequirementListRequirement = em.merge(oldRequirementSpecNodeOfRequirementListRequirement); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findRequirementSpecNode(requirementSpecNode.getRequirementSpecNodePK()) != null) { + throw new PreexistingEntityException("RequirementSpecNode " + requirementSpecNode + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(RequirementSpecNode requirementSpecNode) throws IllegalOrphanException, NonexistentEntityException, Exception { + requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getId()); + requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecProjectId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getProjectId()); + requirementSpecNode.getRequirementSpecNodePK().setRequirementSpecSpecLevelId(requirementSpecNode.getRequirementSpec().getRequirementSpecPK().getSpecLevelId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RequirementSpecNode persistentRequirementSpecNode = em.find(RequirementSpecNode.class, requirementSpecNode.getRequirementSpecNodePK()); + RequirementSpec requirementSpecOld = persistentRequirementSpecNode.getRequirementSpec(); + RequirementSpec requirementSpecNew = requirementSpecNode.getRequirementSpec(); + RequirementSpecNode requirementSpecNodeRelOld = persistentRequirementSpecNode.getRequirementSpecNode(); + RequirementSpecNode requirementSpecNodeRelNew = requirementSpecNode.getRequirementSpecNode(); + List requirementSpecNodeListOld = persistentRequirementSpecNode.getRequirementSpecNodeList(); + List requirementSpecNodeListNew = requirementSpecNode.getRequirementSpecNodeList(); + List requirementListOld = persistentRequirementSpecNode.getRequirementList(); + List requirementListNew = requirementSpecNode.getRequirementList(); + List illegalOrphanMessages = null; + for (Requirement requirementListOldRequirement : requirementListOld) { + if (!requirementListNew.contains(requirementListOldRequirement)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain Requirement " + requirementListOldRequirement + " since its requirementSpecNode field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (requirementSpecNew != null) { + requirementSpecNew = em.getReference(requirementSpecNew.getClass(), requirementSpecNew.getRequirementSpecPK()); + requirementSpecNode.setRequirementSpec(requirementSpecNew); + } + if (requirementSpecNodeRelNew != null) { + requirementSpecNodeRelNew = em.getReference(requirementSpecNodeRelNew.getClass(), requirementSpecNodeRelNew.getRequirementSpecNodePK()); + requirementSpecNode.setRequirementSpecNode(requirementSpecNodeRelNew); + } + List attachedRequirementSpecNodeListNew = new ArrayList<>(); + for (RequirementSpecNode requirementSpecNodeListNewRequirementSpecNodeToAttach : requirementSpecNodeListNew) { + requirementSpecNodeListNewRequirementSpecNodeToAttach = em.getReference(requirementSpecNodeListNewRequirementSpecNodeToAttach.getClass(), requirementSpecNodeListNewRequirementSpecNodeToAttach.getRequirementSpecNodePK()); + attachedRequirementSpecNodeListNew.add(requirementSpecNodeListNewRequirementSpecNodeToAttach); + } + requirementSpecNodeListNew = attachedRequirementSpecNodeListNew; + requirementSpecNode.setRequirementSpecNodeList(requirementSpecNodeListNew); + List attachedRequirementListNew = new ArrayList<>(); + for (Requirement requirementListNewRequirementToAttach : requirementListNew) { + requirementListNewRequirementToAttach = em.getReference(requirementListNewRequirementToAttach.getClass(), requirementListNewRequirementToAttach.getId()); + attachedRequirementListNew.add(requirementListNewRequirementToAttach); + } + requirementListNew = attachedRequirementListNew; + requirementSpecNode.setRequirementList(requirementListNew); + requirementSpecNode = em.merge(requirementSpecNode); + if (requirementSpecOld != null && !requirementSpecOld.equals(requirementSpecNew)) { + requirementSpecOld.getRequirementSpecNodeList().remove(requirementSpecNode); + requirementSpecOld = em.merge(requirementSpecOld); + } + if (requirementSpecNew != null && !requirementSpecNew.equals(requirementSpecOld)) { + requirementSpecNew.getRequirementSpecNodeList().add(requirementSpecNode); + requirementSpecNew = em.merge(requirementSpecNew); + } + if (requirementSpecNodeRelOld != null && !requirementSpecNodeRelOld.equals(requirementSpecNodeRelNew)) { + requirementSpecNodeRelOld.getRequirementSpecNodeList().remove(requirementSpecNode); + requirementSpecNodeRelOld = em.merge(requirementSpecNodeRelOld); + } + if (requirementSpecNodeRelNew != null && !requirementSpecNodeRelNew.equals(requirementSpecNodeRelOld)) { + requirementSpecNodeRelNew.getRequirementSpecNodeList().add(requirementSpecNode); + requirementSpecNodeRelNew = em.merge(requirementSpecNodeRelNew); + } + for (RequirementSpecNode requirementSpecNodeListOldRequirementSpecNode : requirementSpecNodeListOld) { + if (!requirementSpecNodeListNew.contains(requirementSpecNodeListOldRequirementSpecNode)) { + requirementSpecNodeListOldRequirementSpecNode.setRequirementSpecNode(null); + requirementSpecNodeListOldRequirementSpecNode = em.merge(requirementSpecNodeListOldRequirementSpecNode); + } + } + for (RequirementSpecNode requirementSpecNodeListNewRequirementSpecNode : requirementSpecNodeListNew) { + if (!requirementSpecNodeListOld.contains(requirementSpecNodeListNewRequirementSpecNode)) { + RequirementSpecNode oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode = requirementSpecNodeListNewRequirementSpecNode.getRequirementSpecNode(); + requirementSpecNodeListNewRequirementSpecNode.setRequirementSpecNode(requirementSpecNode); + requirementSpecNodeListNewRequirementSpecNode = em.merge(requirementSpecNodeListNewRequirementSpecNode); + if (oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode != null && !oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode.equals(requirementSpecNode)) { + oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode.getRequirementSpecNodeList().remove(requirementSpecNodeListNewRequirementSpecNode); + oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode = em.merge(oldRequirementSpecNodeOfRequirementSpecNodeListNewRequirementSpecNode); + } + } + } + for (Requirement requirementListNewRequirement : requirementListNew) { + if (!requirementListOld.contains(requirementListNewRequirement)) { + RequirementSpecNode oldRequirementSpecNodeOfRequirementListNewRequirement = requirementListNewRequirement.getRequirementSpecNode(); + requirementListNewRequirement.setRequirementSpecNode(requirementSpecNode); + requirementListNewRequirement = em.merge(requirementListNewRequirement); + if (oldRequirementSpecNodeOfRequirementListNewRequirement != null && !oldRequirementSpecNodeOfRequirementListNewRequirement.equals(requirementSpecNode)) { + oldRequirementSpecNodeOfRequirementListNewRequirement.getRequirementList().remove(requirementListNewRequirement); + oldRequirementSpecNodeOfRequirementListNewRequirement = em.merge(oldRequirementSpecNodeOfRequirementListNewRequirement); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + RequirementSpecNodePK id = requirementSpecNode.getRequirementSpecNodePK(); + if (findRequirementSpecNode(id) == null) { + throw new NonexistentEntityException("The requirementSpecNode with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(RequirementSpecNodePK id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RequirementSpecNode requirementSpecNode; + try { + requirementSpecNode = em.getReference(RequirementSpecNode.class, id); + requirementSpecNode.getRequirementSpecNodePK(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The requirementSpecNode with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List requirementListOrphanCheck = requirementSpecNode.getRequirementList(); + for (Requirement requirementListOrphanCheckRequirement : requirementListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RequirementSpecNode (" + requirementSpecNode + ") cannot be destroyed since the Requirement " + requirementListOrphanCheckRequirement + " in its requirementList field has a non-nullable requirementSpecNode field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + RequirementSpec requirementSpec = requirementSpecNode.getRequirementSpec(); + if (requirementSpec != null) { + requirementSpec.getRequirementSpecNodeList().remove(requirementSpecNode); + requirementSpec = em.merge(requirementSpec); + } + RequirementSpecNode requirementSpecNodeRel = requirementSpecNode.getRequirementSpecNode(); + if (requirementSpecNodeRel != null) { + requirementSpecNodeRel.getRequirementSpecNodeList().remove(requirementSpecNode); + requirementSpecNodeRel = em.merge(requirementSpecNodeRel); + } + List requirementSpecNodeList = requirementSpecNode.getRequirementSpecNodeList(); + for (RequirementSpecNode requirementSpecNodeListRequirementSpecNode : requirementSpecNodeList) { + requirementSpecNodeListRequirementSpecNode.setRequirementSpecNode(null); + requirementSpecNodeListRequirementSpecNode = em.merge(requirementSpecNodeListRequirementSpecNode); + } + em.remove(requirementSpecNode); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRequirementSpecNodeEntities() { + return findRequirementSpecNodeEntities(true, -1, -1); + } + + public List findRequirementSpecNodeEntities(int maxResults, int firstResult) { + return findRequirementSpecNodeEntities(false, maxResults, firstResult); + } + + private List findRequirementSpecNodeEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(RequirementSpecNode.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public RequirementSpecNode findRequirementSpecNode(RequirementSpecNodePK id) { + EntityManager em = getEntityManager(); + try { + return em.find(RequirementSpecNode.class, id); + } + finally { + em.close(); + } + } + + public int getRequirementSpecNodeCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(RequirementSpecNode.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementStatusJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementStatusJpaController.java index 0c4879a9..a06633dd 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementStatusJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementStatusJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Requirement; -import com.validation.manager.core.db.RequirementStatus; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RequirementStatusJpaController implements Serializable { - - public RequirementStatusJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(RequirementStatus requirementStatus) { - if (requirementStatus.getRequirementList() == null) { - requirementStatus.setRequirementList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedRequirementList = new ArrayList(); - for (Requirement requirementListRequirementToAttach : requirementStatus.getRequirementList()) { - requirementListRequirementToAttach = em.getReference(requirementListRequirementToAttach.getClass(), requirementListRequirementToAttach.getId()); - attachedRequirementList.add(requirementListRequirementToAttach); - } - requirementStatus.setRequirementList(attachedRequirementList); - em.persist(requirementStatus); - for (Requirement requirementListRequirement : requirementStatus.getRequirementList()) { - RequirementStatus oldRequirementStatusIdOfRequirementListRequirement = requirementListRequirement.getRequirementStatusId(); - requirementListRequirement.setRequirementStatusId(requirementStatus); - requirementListRequirement = em.merge(requirementListRequirement); - if (oldRequirementStatusIdOfRequirementListRequirement != null) { - oldRequirementStatusIdOfRequirementListRequirement.getRequirementList().remove(requirementListRequirement); - oldRequirementStatusIdOfRequirementListRequirement = em.merge(oldRequirementStatusIdOfRequirementListRequirement); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(RequirementStatus requirementStatus) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RequirementStatus persistentRequirementStatus = em.find(RequirementStatus.class, requirementStatus.getId()); - List requirementListOld = persistentRequirementStatus.getRequirementList(); - List requirementListNew = requirementStatus.getRequirementList(); - List illegalOrphanMessages = null; - for (Requirement requirementListOldRequirement : requirementListOld) { - if (!requirementListNew.contains(requirementListOldRequirement)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain Requirement " + requirementListOldRequirement + " since its requirementStatusId field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedRequirementListNew = new ArrayList(); - for (Requirement requirementListNewRequirementToAttach : requirementListNew) { - requirementListNewRequirementToAttach = em.getReference(requirementListNewRequirementToAttach.getClass(), requirementListNewRequirementToAttach.getId()); - attachedRequirementListNew.add(requirementListNewRequirementToAttach); - } - requirementListNew = attachedRequirementListNew; - requirementStatus.setRequirementList(requirementListNew); - requirementStatus = em.merge(requirementStatus); - for (Requirement requirementListNewRequirement : requirementListNew) { - if (!requirementListOld.contains(requirementListNewRequirement)) { - RequirementStatus oldRequirementStatusIdOfRequirementListNewRequirement = requirementListNewRequirement.getRequirementStatusId(); - requirementListNewRequirement.setRequirementStatusId(requirementStatus); - requirementListNewRequirement = em.merge(requirementListNewRequirement); - if (oldRequirementStatusIdOfRequirementListNewRequirement != null && !oldRequirementStatusIdOfRequirementListNewRequirement.equals(requirementStatus)) { - oldRequirementStatusIdOfRequirementListNewRequirement.getRequirementList().remove(requirementListNewRequirement); - oldRequirementStatusIdOfRequirementListNewRequirement = em.merge(oldRequirementStatusIdOfRequirementListNewRequirement); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = requirementStatus.getId(); - if (findRequirementStatus(id) == null) { - throw new NonexistentEntityException("The requirementStatus with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RequirementStatus requirementStatus; - try { - requirementStatus = em.getReference(RequirementStatus.class, id); - requirementStatus.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The requirementStatus with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List requirementListOrphanCheck = requirementStatus.getRequirementList(); - for (Requirement requirementListOrphanCheckRequirement : requirementListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RequirementStatus (" + requirementStatus + ") cannot be destroyed since the Requirement " + requirementListOrphanCheckRequirement + " in its requirementList field has a non-nullable requirementStatusId field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(requirementStatus); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRequirementStatusEntities() { - return findRequirementStatusEntities(true, -1, -1); - } - - public List findRequirementStatusEntities(int maxResults, int firstResult) { - return findRequirementStatusEntities(false, maxResults, firstResult); - } - - private List findRequirementStatusEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(RequirementStatus.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public RequirementStatus findRequirementStatus(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(RequirementStatus.class, id); - } - finally { - em.close(); - } - } - - public int getRequirementStatusCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(RequirementStatus.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Requirement; +import com.validation.manager.core.db.RequirementStatus; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RequirementStatusJpaController implements Serializable { + + public RequirementStatusJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(RequirementStatus requirementStatus) { + if (requirementStatus.getRequirementList() == null) { + requirementStatus.setRequirementList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedRequirementList = new ArrayList<>(); + for (Requirement requirementListRequirementToAttach : requirementStatus.getRequirementList()) { + requirementListRequirementToAttach = em.getReference(requirementListRequirementToAttach.getClass(), requirementListRequirementToAttach.getId()); + attachedRequirementList.add(requirementListRequirementToAttach); + } + requirementStatus.setRequirementList(attachedRequirementList); + em.persist(requirementStatus); + for (Requirement requirementListRequirement : requirementStatus.getRequirementList()) { + RequirementStatus oldRequirementStatusIdOfRequirementListRequirement = requirementListRequirement.getRequirementStatusId(); + requirementListRequirement.setRequirementStatusId(requirementStatus); + requirementListRequirement = em.merge(requirementListRequirement); + if (oldRequirementStatusIdOfRequirementListRequirement != null) { + oldRequirementStatusIdOfRequirementListRequirement.getRequirementList().remove(requirementListRequirement); + oldRequirementStatusIdOfRequirementListRequirement = em.merge(oldRequirementStatusIdOfRequirementListRequirement); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(RequirementStatus requirementStatus) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RequirementStatus persistentRequirementStatus = em.find(RequirementStatus.class, requirementStatus.getId()); + List requirementListOld = persistentRequirementStatus.getRequirementList(); + List requirementListNew = requirementStatus.getRequirementList(); + List illegalOrphanMessages = null; + for (Requirement requirementListOldRequirement : requirementListOld) { + if (!requirementListNew.contains(requirementListOldRequirement)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain Requirement " + requirementListOldRequirement + " since its requirementStatusId field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedRequirementListNew = new ArrayList<>(); + for (Requirement requirementListNewRequirementToAttach : requirementListNew) { + requirementListNewRequirementToAttach = em.getReference(requirementListNewRequirementToAttach.getClass(), requirementListNewRequirementToAttach.getId()); + attachedRequirementListNew.add(requirementListNewRequirementToAttach); + } + requirementListNew = attachedRequirementListNew; + requirementStatus.setRequirementList(requirementListNew); + requirementStatus = em.merge(requirementStatus); + for (Requirement requirementListNewRequirement : requirementListNew) { + if (!requirementListOld.contains(requirementListNewRequirement)) { + RequirementStatus oldRequirementStatusIdOfRequirementListNewRequirement = requirementListNewRequirement.getRequirementStatusId(); + requirementListNewRequirement.setRequirementStatusId(requirementStatus); + requirementListNewRequirement = em.merge(requirementListNewRequirement); + if (oldRequirementStatusIdOfRequirementListNewRequirement != null && !oldRequirementStatusIdOfRequirementListNewRequirement.equals(requirementStatus)) { + oldRequirementStatusIdOfRequirementListNewRequirement.getRequirementList().remove(requirementListNewRequirement); + oldRequirementStatusIdOfRequirementListNewRequirement = em.merge(oldRequirementStatusIdOfRequirementListNewRequirement); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = requirementStatus.getId(); + if (findRequirementStatus(id) == null) { + throw new NonexistentEntityException("The requirementStatus with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RequirementStatus requirementStatus; + try { + requirementStatus = em.getReference(RequirementStatus.class, id); + requirementStatus.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The requirementStatus with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List requirementListOrphanCheck = requirementStatus.getRequirementList(); + for (Requirement requirementListOrphanCheckRequirement : requirementListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RequirementStatus (" + requirementStatus + ") cannot be destroyed since the Requirement " + requirementListOrphanCheckRequirement + " in its requirementList field has a non-nullable requirementStatusId field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(requirementStatus); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRequirementStatusEntities() { + return findRequirementStatusEntities(true, -1, -1); + } + + public List findRequirementStatusEntities(int maxResults, int firstResult) { + return findRequirementStatusEntities(false, maxResults, firstResult); + } + + private List findRequirementStatusEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(RequirementStatus.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public RequirementStatus findRequirementStatus(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(RequirementStatus.class, id); + } + finally { + em.close(); + } + } + + public int getRequirementStatusCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(RequirementStatus.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementTypeJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementTypeJpaController.java index fbf4cff6..d07cc7a4 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementTypeJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RequirementTypeJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Requirement; -import com.validation.manager.core.db.RequirementType; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RequirementTypeJpaController implements Serializable { - - public RequirementTypeJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(RequirementType requirementType) { - if (requirementType.getRequirementList() == null) { - requirementType.setRequirementList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedRequirementList = new ArrayList(); - for (Requirement requirementListRequirementToAttach : requirementType.getRequirementList()) { - requirementListRequirementToAttach = em.getReference(requirementListRequirementToAttach.getClass(), requirementListRequirementToAttach.getId()); - attachedRequirementList.add(requirementListRequirementToAttach); - } - requirementType.setRequirementList(attachedRequirementList); - em.persist(requirementType); - for (Requirement requirementListRequirement : requirementType.getRequirementList()) { - RequirementType oldRequirementTypeIdOfRequirementListRequirement = requirementListRequirement.getRequirementTypeId(); - requirementListRequirement.setRequirementTypeId(requirementType); - requirementListRequirement = em.merge(requirementListRequirement); - if (oldRequirementTypeIdOfRequirementListRequirement != null) { - oldRequirementTypeIdOfRequirementListRequirement.getRequirementList().remove(requirementListRequirement); - oldRequirementTypeIdOfRequirementListRequirement = em.merge(oldRequirementTypeIdOfRequirementListRequirement); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(RequirementType requirementType) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RequirementType persistentRequirementType = em.find(RequirementType.class, requirementType.getId()); - List requirementListOld = persistentRequirementType.getRequirementList(); - List requirementListNew = requirementType.getRequirementList(); - List illegalOrphanMessages = null; - for (Requirement requirementListOldRequirement : requirementListOld) { - if (!requirementListNew.contains(requirementListOldRequirement)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain Requirement " + requirementListOldRequirement + " since its requirementTypeId field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedRequirementListNew = new ArrayList(); - for (Requirement requirementListNewRequirementToAttach : requirementListNew) { - requirementListNewRequirementToAttach = em.getReference(requirementListNewRequirementToAttach.getClass(), requirementListNewRequirementToAttach.getId()); - attachedRequirementListNew.add(requirementListNewRequirementToAttach); - } - requirementListNew = attachedRequirementListNew; - requirementType.setRequirementList(requirementListNew); - requirementType = em.merge(requirementType); - for (Requirement requirementListNewRequirement : requirementListNew) { - if (!requirementListOld.contains(requirementListNewRequirement)) { - RequirementType oldRequirementTypeIdOfRequirementListNewRequirement = requirementListNewRequirement.getRequirementTypeId(); - requirementListNewRequirement.setRequirementTypeId(requirementType); - requirementListNewRequirement = em.merge(requirementListNewRequirement); - if (oldRequirementTypeIdOfRequirementListNewRequirement != null && !oldRequirementTypeIdOfRequirementListNewRequirement.equals(requirementType)) { - oldRequirementTypeIdOfRequirementListNewRequirement.getRequirementList().remove(requirementListNewRequirement); - oldRequirementTypeIdOfRequirementListNewRequirement = em.merge(oldRequirementTypeIdOfRequirementListNewRequirement); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = requirementType.getId(); - if (findRequirementType(id) == null) { - throw new NonexistentEntityException("The requirementType with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RequirementType requirementType; - try { - requirementType = em.getReference(RequirementType.class, id); - requirementType.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The requirementType with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List requirementListOrphanCheck = requirementType.getRequirementList(); - for (Requirement requirementListOrphanCheckRequirement : requirementListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RequirementType (" + requirementType + ") cannot be destroyed since the Requirement " + requirementListOrphanCheckRequirement + " in its requirementList field has a non-nullable requirementTypeId field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(requirementType); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRequirementTypeEntities() { - return findRequirementTypeEntities(true, -1, -1); - } - - public List findRequirementTypeEntities(int maxResults, int firstResult) { - return findRequirementTypeEntities(false, maxResults, firstResult); - } - - private List findRequirementTypeEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(RequirementType.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public RequirementType findRequirementType(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(RequirementType.class, id); - } - finally { - em.close(); - } - } - - public int getRequirementTypeCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(RequirementType.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Requirement; +import com.validation.manager.core.db.RequirementType; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RequirementTypeJpaController implements Serializable { + + public RequirementTypeJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(RequirementType requirementType) { + if (requirementType.getRequirementList() == null) { + requirementType.setRequirementList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedRequirementList = new ArrayList<>(); + for (Requirement requirementListRequirementToAttach : requirementType.getRequirementList()) { + requirementListRequirementToAttach = em.getReference(requirementListRequirementToAttach.getClass(), requirementListRequirementToAttach.getId()); + attachedRequirementList.add(requirementListRequirementToAttach); + } + requirementType.setRequirementList(attachedRequirementList); + em.persist(requirementType); + for (Requirement requirementListRequirement : requirementType.getRequirementList()) { + RequirementType oldRequirementTypeIdOfRequirementListRequirement = requirementListRequirement.getRequirementTypeId(); + requirementListRequirement.setRequirementTypeId(requirementType); + requirementListRequirement = em.merge(requirementListRequirement); + if (oldRequirementTypeIdOfRequirementListRequirement != null) { + oldRequirementTypeIdOfRequirementListRequirement.getRequirementList().remove(requirementListRequirement); + oldRequirementTypeIdOfRequirementListRequirement = em.merge(oldRequirementTypeIdOfRequirementListRequirement); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(RequirementType requirementType) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RequirementType persistentRequirementType = em.find(RequirementType.class, requirementType.getId()); + List requirementListOld = persistentRequirementType.getRequirementList(); + List requirementListNew = requirementType.getRequirementList(); + List illegalOrphanMessages = null; + for (Requirement requirementListOldRequirement : requirementListOld) { + if (!requirementListNew.contains(requirementListOldRequirement)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain Requirement " + requirementListOldRequirement + " since its requirementTypeId field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedRequirementListNew = new ArrayList<>(); + for (Requirement requirementListNewRequirementToAttach : requirementListNew) { + requirementListNewRequirementToAttach = em.getReference(requirementListNewRequirementToAttach.getClass(), requirementListNewRequirementToAttach.getId()); + attachedRequirementListNew.add(requirementListNewRequirementToAttach); + } + requirementListNew = attachedRequirementListNew; + requirementType.setRequirementList(requirementListNew); + requirementType = em.merge(requirementType); + for (Requirement requirementListNewRequirement : requirementListNew) { + if (!requirementListOld.contains(requirementListNewRequirement)) { + RequirementType oldRequirementTypeIdOfRequirementListNewRequirement = requirementListNewRequirement.getRequirementTypeId(); + requirementListNewRequirement.setRequirementTypeId(requirementType); + requirementListNewRequirement = em.merge(requirementListNewRequirement); + if (oldRequirementTypeIdOfRequirementListNewRequirement != null && !oldRequirementTypeIdOfRequirementListNewRequirement.equals(requirementType)) { + oldRequirementTypeIdOfRequirementListNewRequirement.getRequirementList().remove(requirementListNewRequirement); + oldRequirementTypeIdOfRequirementListNewRequirement = em.merge(oldRequirementTypeIdOfRequirementListNewRequirement); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = requirementType.getId(); + if (findRequirementType(id) == null) { + throw new NonexistentEntityException("The requirementType with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RequirementType requirementType; + try { + requirementType = em.getReference(RequirementType.class, id); + requirementType.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The requirementType with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List requirementListOrphanCheck = requirementType.getRequirementList(); + for (Requirement requirementListOrphanCheckRequirement : requirementListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RequirementType (" + requirementType + ") cannot be destroyed since the Requirement " + requirementListOrphanCheckRequirement + " in its requirementList field has a non-nullable requirementTypeId field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(requirementType); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRequirementTypeEntities() { + return findRequirementTypeEntities(true, -1, -1); + } + + public List findRequirementTypeEntities(int maxResults, int firstResult) { + return findRequirementTypeEntities(false, maxResults, firstResult); + } + + private List findRequirementTypeEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(RequirementType.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public RequirementType findRequirementType(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(RequirementType.class, id); + } + finally { + em.close(); + } + } + + public int getRequirementTypeCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(RequirementType.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/ReviewResultJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/ReviewResultJpaController.java index 58a61f66..b84cf788 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/ReviewResultJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/ReviewResultJpaController.java @@ -13,196 +13,196 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.ReviewResult; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class ReviewResultJpaController implements Serializable { - - public ReviewResultJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(ReviewResult reviewResult) { - if (reviewResult.getExecutionStepList() == null) { - reviewResult.setExecutionStepList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedExecutionStepList = new ArrayList(); - for (ExecutionStep executionStepListExecutionStepToAttach : reviewResult.getExecutionStepList()) { - executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepList.add(executionStepListExecutionStepToAttach); - } - reviewResult.setExecutionStepList(attachedExecutionStepList); - em.persist(reviewResult); - for (ExecutionStep executionStepListExecutionStep : reviewResult.getExecutionStepList()) { - ReviewResult oldReviewResultIdOfExecutionStepListExecutionStep = executionStepListExecutionStep.getReviewResultId(); - executionStepListExecutionStep.setReviewResultId(reviewResult); - executionStepListExecutionStep = em.merge(executionStepListExecutionStep); - if (oldReviewResultIdOfExecutionStepListExecutionStep != null) { - oldReviewResultIdOfExecutionStepListExecutionStep.getExecutionStepList().remove(executionStepListExecutionStep); - oldReviewResultIdOfExecutionStepListExecutionStep = em.merge(oldReviewResultIdOfExecutionStepListExecutionStep); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(ReviewResult reviewResult) throws NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - ReviewResult persistentReviewResult = em.find(ReviewResult.class, reviewResult.getId()); - List executionStepListOld = persistentReviewResult.getExecutionStepList(); - List executionStepListNew = reviewResult.getExecutionStepList(); - List attachedExecutionStepListNew = new ArrayList(); - for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { - executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); - } - executionStepListNew = attachedExecutionStepListNew; - reviewResult.setExecutionStepList(executionStepListNew); - reviewResult = em.merge(reviewResult); - for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { - if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { - executionStepListOldExecutionStep.setReviewResultId(null); - executionStepListOldExecutionStep = em.merge(executionStepListOldExecutionStep); - } - } - for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { - if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { - ReviewResult oldReviewResultIdOfExecutionStepListNewExecutionStep = executionStepListNewExecutionStep.getReviewResultId(); - executionStepListNewExecutionStep.setReviewResultId(reviewResult); - executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); - if (oldReviewResultIdOfExecutionStepListNewExecutionStep != null && !oldReviewResultIdOfExecutionStepListNewExecutionStep.equals(reviewResult)) { - oldReviewResultIdOfExecutionStepListNewExecutionStep.getExecutionStepList().remove(executionStepListNewExecutionStep); - oldReviewResultIdOfExecutionStepListNewExecutionStep = em.merge(oldReviewResultIdOfExecutionStepListNewExecutionStep); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = reviewResult.getId(); - if (findReviewResult(id) == null) { - throw new NonexistentEntityException("The reviewResult with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - ReviewResult reviewResult; - try { - reviewResult = em.getReference(ReviewResult.class, id); - reviewResult.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The reviewResult with id " + id + " no longer exists.", enfe); - } - List executionStepList = reviewResult.getExecutionStepList(); - for (ExecutionStep executionStepListExecutionStep : executionStepList) { - executionStepListExecutionStep.setReviewResultId(null); - executionStepListExecutionStep = em.merge(executionStepListExecutionStep); - } - em.remove(reviewResult); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findReviewResultEntities() { - return findReviewResultEntities(true, -1, -1); - } - - public List findReviewResultEntities(int maxResults, int firstResult) { - return findReviewResultEntities(false, maxResults, firstResult); - } - - private List findReviewResultEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(ReviewResult.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public ReviewResult findReviewResult(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(ReviewResult.class, id); - } - finally { - em.close(); - } - } - - public int getReviewResultCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(ReviewResult.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.ReviewResult; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ReviewResultJpaController implements Serializable { + + public ReviewResultJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(ReviewResult reviewResult) { + if (reviewResult.getExecutionStepList() == null) { + reviewResult.setExecutionStepList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedExecutionStepList = new ArrayList<>(); + for (ExecutionStep executionStepListExecutionStepToAttach : reviewResult.getExecutionStepList()) { + executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepList.add(executionStepListExecutionStepToAttach); + } + reviewResult.setExecutionStepList(attachedExecutionStepList); + em.persist(reviewResult); + for (ExecutionStep executionStepListExecutionStep : reviewResult.getExecutionStepList()) { + ReviewResult oldReviewResultIdOfExecutionStepListExecutionStep = executionStepListExecutionStep.getReviewResultId(); + executionStepListExecutionStep.setReviewResultId(reviewResult); + executionStepListExecutionStep = em.merge(executionStepListExecutionStep); + if (oldReviewResultIdOfExecutionStepListExecutionStep != null) { + oldReviewResultIdOfExecutionStepListExecutionStep.getExecutionStepList().remove(executionStepListExecutionStep); + oldReviewResultIdOfExecutionStepListExecutionStep = em.merge(oldReviewResultIdOfExecutionStepListExecutionStep); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(ReviewResult reviewResult) throws NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + ReviewResult persistentReviewResult = em.find(ReviewResult.class, reviewResult.getId()); + List executionStepListOld = persistentReviewResult.getExecutionStepList(); + List executionStepListNew = reviewResult.getExecutionStepList(); + List attachedExecutionStepListNew = new ArrayList<>(); + for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { + executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); + } + executionStepListNew = attachedExecutionStepListNew; + reviewResult.setExecutionStepList(executionStepListNew); + reviewResult = em.merge(reviewResult); + for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { + if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { + executionStepListOldExecutionStep.setReviewResultId(null); + executionStepListOldExecutionStep = em.merge(executionStepListOldExecutionStep); + } + } + for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { + if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { + ReviewResult oldReviewResultIdOfExecutionStepListNewExecutionStep = executionStepListNewExecutionStep.getReviewResultId(); + executionStepListNewExecutionStep.setReviewResultId(reviewResult); + executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); + if (oldReviewResultIdOfExecutionStepListNewExecutionStep != null && !oldReviewResultIdOfExecutionStepListNewExecutionStep.equals(reviewResult)) { + oldReviewResultIdOfExecutionStepListNewExecutionStep.getExecutionStepList().remove(executionStepListNewExecutionStep); + oldReviewResultIdOfExecutionStepListNewExecutionStep = em.merge(oldReviewResultIdOfExecutionStepListNewExecutionStep); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = reviewResult.getId(); + if (findReviewResult(id) == null) { + throw new NonexistentEntityException("The reviewResult with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + ReviewResult reviewResult; + try { + reviewResult = em.getReference(ReviewResult.class, id); + reviewResult.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The reviewResult with id " + id + " no longer exists.", enfe); + } + List executionStepList = reviewResult.getExecutionStepList(); + for (ExecutionStep executionStepListExecutionStep : executionStepList) { + executionStepListExecutionStep.setReviewResultId(null); + executionStepListExecutionStep = em.merge(executionStepListExecutionStep); + } + em.remove(reviewResult); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findReviewResultEntities() { + return findReviewResultEntities(true, -1, -1); + } + + public List findReviewResultEntities(int maxResults, int firstResult) { + return findReviewResultEntities(false, maxResults, firstResult); + } + + private List findReviewResultEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(ReviewResult.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public ReviewResult findReviewResult(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(ReviewResult.class, id); + } + finally { + em.close(); + } + } + + public int getReviewResultCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(ReviewResult.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskCategoryJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskCategoryJpaController.java index 0c3af823..51bdb7a9 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskCategoryJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskCategoryJpaController.java @@ -13,249 +13,249 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Fmea; -import com.validation.manager.core.db.RiskCategory; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.RiskItemHasRiskCategory; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RiskCategoryJpaController implements Serializable { - - public RiskCategoryJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(RiskCategory riskCategory) { - if (riskCategory.getFmeaList() == null) { - riskCategory.setFmeaList(new ArrayList()); - } - if (riskCategory.getRiskItemHasRiskCategoryList() == null) { - riskCategory.setRiskItemHasRiskCategoryList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedFmeaList = new ArrayList(); - for (Fmea fmeaListFmeaToAttach : riskCategory.getFmeaList()) { - fmeaListFmeaToAttach = em.getReference(fmeaListFmeaToAttach.getClass(), fmeaListFmeaToAttach.getId()); - attachedFmeaList.add(fmeaListFmeaToAttach); - } - riskCategory.setFmeaList(attachedFmeaList); - List attachedRiskItemHasRiskCategoryList = new ArrayList(); - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach : riskCategory.getRiskItemHasRiskCategoryList()) { - riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach = em.getReference(riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach.getClass(), riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach.getRiskItemHasRiskCategoryPK()); - attachedRiskItemHasRiskCategoryList.add(riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach); - } - riskCategory.setRiskItemHasRiskCategoryList(attachedRiskItemHasRiskCategoryList); - em.persist(riskCategory); - for (Fmea fmeaListFmea : riskCategory.getFmeaList()) { - fmeaListFmea.getRiskCategoryList().add(riskCategory); - fmeaListFmea = em.merge(fmeaListFmea); - } - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListRiskItemHasRiskCategory : riskCategory.getRiskItemHasRiskCategoryList()) { - RiskCategory oldRiskCategoryOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory = riskItemHasRiskCategoryListRiskItemHasRiskCategory.getRiskCategory(); - riskItemHasRiskCategoryListRiskItemHasRiskCategory.setRiskCategory(riskCategory); - riskItemHasRiskCategoryListRiskItemHasRiskCategory = em.merge(riskItemHasRiskCategoryListRiskItemHasRiskCategory); - if (oldRiskCategoryOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory != null) { - oldRiskCategoryOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory.getRiskItemHasRiskCategoryList().remove(riskItemHasRiskCategoryListRiskItemHasRiskCategory); - oldRiskCategoryOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory = em.merge(oldRiskCategoryOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(RiskCategory riskCategory) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RiskCategory persistentRiskCategory = em.find(RiskCategory.class, riskCategory.getId()); - List fmeaListOld = persistentRiskCategory.getFmeaList(); - List fmeaListNew = riskCategory.getFmeaList(); - List riskItemHasRiskCategoryListOld = persistentRiskCategory.getRiskItemHasRiskCategoryList(); - List riskItemHasRiskCategoryListNew = riskCategory.getRiskItemHasRiskCategoryList(); - List illegalOrphanMessages = null; - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListOldRiskItemHasRiskCategory : riskItemHasRiskCategoryListOld) { - if (!riskItemHasRiskCategoryListNew.contains(riskItemHasRiskCategoryListOldRiskItemHasRiskCategory)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RiskItemHasRiskCategory " + riskItemHasRiskCategoryListOldRiskItemHasRiskCategory + " since its riskCategory field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedFmeaListNew = new ArrayList(); - for (Fmea fmeaListNewFmeaToAttach : fmeaListNew) { - fmeaListNewFmeaToAttach = em.getReference(fmeaListNewFmeaToAttach.getClass(), fmeaListNewFmeaToAttach.getId()); - attachedFmeaListNew.add(fmeaListNewFmeaToAttach); - } - fmeaListNew = attachedFmeaListNew; - riskCategory.setFmeaList(fmeaListNew); - List attachedRiskItemHasRiskCategoryListNew = new ArrayList(); - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach : riskItemHasRiskCategoryListNew) { - riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach = em.getReference(riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach.getClass(), riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach.getRiskItemHasRiskCategoryPK()); - attachedRiskItemHasRiskCategoryListNew.add(riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach); - } - riskItemHasRiskCategoryListNew = attachedRiskItemHasRiskCategoryListNew; - riskCategory.setRiskItemHasRiskCategoryList(riskItemHasRiskCategoryListNew); - riskCategory = em.merge(riskCategory); - for (Fmea fmeaListOldFmea : fmeaListOld) { - if (!fmeaListNew.contains(fmeaListOldFmea)) { - fmeaListOldFmea.getRiskCategoryList().remove(riskCategory); - fmeaListOldFmea = em.merge(fmeaListOldFmea); - } - } - for (Fmea fmeaListNewFmea : fmeaListNew) { - if (!fmeaListOld.contains(fmeaListNewFmea)) { - fmeaListNewFmea.getRiskCategoryList().add(riskCategory); - fmeaListNewFmea = em.merge(fmeaListNewFmea); - } - } - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListNewRiskItemHasRiskCategory : riskItemHasRiskCategoryListNew) { - if (!riskItemHasRiskCategoryListOld.contains(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory)) { - RiskCategory oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory = riskItemHasRiskCategoryListNewRiskItemHasRiskCategory.getRiskCategory(); - riskItemHasRiskCategoryListNewRiskItemHasRiskCategory.setRiskCategory(riskCategory); - riskItemHasRiskCategoryListNewRiskItemHasRiskCategory = em.merge(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory); - if (oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory != null && !oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory.equals(riskCategory)) { - oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory.getRiskItemHasRiskCategoryList().remove(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory); - oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory = em.merge(oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = riskCategory.getId(); - if (findRiskCategory(id) == null) { - throw new NonexistentEntityException("The riskCategory with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RiskCategory riskCategory; - try { - riskCategory = em.getReference(RiskCategory.class, id); - riskCategory.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The riskCategory with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List riskItemHasRiskCategoryListOrphanCheck = riskCategory.getRiskItemHasRiskCategoryList(); - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListOrphanCheckRiskItemHasRiskCategory : riskItemHasRiskCategoryListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RiskCategory (" + riskCategory + ") cannot be destroyed since the RiskItemHasRiskCategory " + riskItemHasRiskCategoryListOrphanCheckRiskItemHasRiskCategory + " in its riskItemHasRiskCategoryList field has a non-nullable riskCategory field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List fmeaList = riskCategory.getFmeaList(); - for (Fmea fmeaListFmea : fmeaList) { - fmeaListFmea.getRiskCategoryList().remove(riskCategory); - fmeaListFmea = em.merge(fmeaListFmea); - } - em.remove(riskCategory); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRiskCategoryEntities() { - return findRiskCategoryEntities(true, -1, -1); - } - - public List findRiskCategoryEntities(int maxResults, int firstResult) { - return findRiskCategoryEntities(false, maxResults, firstResult); - } - - private List findRiskCategoryEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(RiskCategory.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public RiskCategory findRiskCategory(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(RiskCategory.class, id); - } - finally { - em.close(); - } - } - - public int getRiskCategoryCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(RiskCategory.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Fmea; +import com.validation.manager.core.db.RiskCategory; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.RiskItemHasRiskCategory; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RiskCategoryJpaController implements Serializable { + + public RiskCategoryJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(RiskCategory riskCategory) { + if (riskCategory.getFmeaList() == null) { + riskCategory.setFmeaList(new ArrayList<>()); + } + if (riskCategory.getRiskItemHasRiskCategoryList() == null) { + riskCategory.setRiskItemHasRiskCategoryList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedFmeaList = new ArrayList<>(); + for (Fmea fmeaListFmeaToAttach : riskCategory.getFmeaList()) { + fmeaListFmeaToAttach = em.getReference(fmeaListFmeaToAttach.getClass(), fmeaListFmeaToAttach.getId()); + attachedFmeaList.add(fmeaListFmeaToAttach); + } + riskCategory.setFmeaList(attachedFmeaList); + List attachedRiskItemHasRiskCategoryList = new ArrayList<>(); + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach : riskCategory.getRiskItemHasRiskCategoryList()) { + riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach = em.getReference(riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach.getClass(), riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach.getRiskItemHasRiskCategoryPK()); + attachedRiskItemHasRiskCategoryList.add(riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach); + } + riskCategory.setRiskItemHasRiskCategoryList(attachedRiskItemHasRiskCategoryList); + em.persist(riskCategory); + for (Fmea fmeaListFmea : riskCategory.getFmeaList()) { + fmeaListFmea.getRiskCategoryList().add(riskCategory); + fmeaListFmea = em.merge(fmeaListFmea); + } + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListRiskItemHasRiskCategory : riskCategory.getRiskItemHasRiskCategoryList()) { + RiskCategory oldRiskCategoryOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory = riskItemHasRiskCategoryListRiskItemHasRiskCategory.getRiskCategory(); + riskItemHasRiskCategoryListRiskItemHasRiskCategory.setRiskCategory(riskCategory); + riskItemHasRiskCategoryListRiskItemHasRiskCategory = em.merge(riskItemHasRiskCategoryListRiskItemHasRiskCategory); + if (oldRiskCategoryOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory != null) { + oldRiskCategoryOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory.getRiskItemHasRiskCategoryList().remove(riskItemHasRiskCategoryListRiskItemHasRiskCategory); + oldRiskCategoryOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory = em.merge(oldRiskCategoryOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(RiskCategory riskCategory) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RiskCategory persistentRiskCategory = em.find(RiskCategory.class, riskCategory.getId()); + List fmeaListOld = persistentRiskCategory.getFmeaList(); + List fmeaListNew = riskCategory.getFmeaList(); + List riskItemHasRiskCategoryListOld = persistentRiskCategory.getRiskItemHasRiskCategoryList(); + List riskItemHasRiskCategoryListNew = riskCategory.getRiskItemHasRiskCategoryList(); + List illegalOrphanMessages = null; + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListOldRiskItemHasRiskCategory : riskItemHasRiskCategoryListOld) { + if (!riskItemHasRiskCategoryListNew.contains(riskItemHasRiskCategoryListOldRiskItemHasRiskCategory)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RiskItemHasRiskCategory " + riskItemHasRiskCategoryListOldRiskItemHasRiskCategory + " since its riskCategory field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedFmeaListNew = new ArrayList<>(); + for (Fmea fmeaListNewFmeaToAttach : fmeaListNew) { + fmeaListNewFmeaToAttach = em.getReference(fmeaListNewFmeaToAttach.getClass(), fmeaListNewFmeaToAttach.getId()); + attachedFmeaListNew.add(fmeaListNewFmeaToAttach); + } + fmeaListNew = attachedFmeaListNew; + riskCategory.setFmeaList(fmeaListNew); + List attachedRiskItemHasRiskCategoryListNew = new ArrayList<>(); + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach : riskItemHasRiskCategoryListNew) { + riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach = em.getReference(riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach.getClass(), riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach.getRiskItemHasRiskCategoryPK()); + attachedRiskItemHasRiskCategoryListNew.add(riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach); + } + riskItemHasRiskCategoryListNew = attachedRiskItemHasRiskCategoryListNew; + riskCategory.setRiskItemHasRiskCategoryList(riskItemHasRiskCategoryListNew); + riskCategory = em.merge(riskCategory); + for (Fmea fmeaListOldFmea : fmeaListOld) { + if (!fmeaListNew.contains(fmeaListOldFmea)) { + fmeaListOldFmea.getRiskCategoryList().remove(riskCategory); + fmeaListOldFmea = em.merge(fmeaListOldFmea); + } + } + for (Fmea fmeaListNewFmea : fmeaListNew) { + if (!fmeaListOld.contains(fmeaListNewFmea)) { + fmeaListNewFmea.getRiskCategoryList().add(riskCategory); + fmeaListNewFmea = em.merge(fmeaListNewFmea); + } + } + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListNewRiskItemHasRiskCategory : riskItemHasRiskCategoryListNew) { + if (!riskItemHasRiskCategoryListOld.contains(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory)) { + RiskCategory oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory = riskItemHasRiskCategoryListNewRiskItemHasRiskCategory.getRiskCategory(); + riskItemHasRiskCategoryListNewRiskItemHasRiskCategory.setRiskCategory(riskCategory); + riskItemHasRiskCategoryListNewRiskItemHasRiskCategory = em.merge(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory); + if (oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory != null && !oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory.equals(riskCategory)) { + oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory.getRiskItemHasRiskCategoryList().remove(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory); + oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory = em.merge(oldRiskCategoryOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = riskCategory.getId(); + if (findRiskCategory(id) == null) { + throw new NonexistentEntityException("The riskCategory with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RiskCategory riskCategory; + try { + riskCategory = em.getReference(RiskCategory.class, id); + riskCategory.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The riskCategory with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List riskItemHasRiskCategoryListOrphanCheck = riskCategory.getRiskItemHasRiskCategoryList(); + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListOrphanCheckRiskItemHasRiskCategory : riskItemHasRiskCategoryListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RiskCategory (" + riskCategory + ") cannot be destroyed since the RiskItemHasRiskCategory " + riskItemHasRiskCategoryListOrphanCheckRiskItemHasRiskCategory + " in its riskItemHasRiskCategoryList field has a non-nullable riskCategory field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List fmeaList = riskCategory.getFmeaList(); + for (Fmea fmeaListFmea : fmeaList) { + fmeaListFmea.getRiskCategoryList().remove(riskCategory); + fmeaListFmea = em.merge(fmeaListFmea); + } + em.remove(riskCategory); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRiskCategoryEntities() { + return findRiskCategoryEntities(true, -1, -1); + } + + public List findRiskCategoryEntities(int maxResults, int firstResult) { + return findRiskCategoryEntities(false, maxResults, firstResult); + } + + private List findRiskCategoryEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(RiskCategory.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public RiskCategory findRiskCategory(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(RiskCategory.class, id); + } + finally { + em.close(); + } + } + + public int getRiskCategoryCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(RiskCategory.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskControlJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskControlJpaController.java index 1313ca87..6b41812b 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskControlJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskControlJpaController.java @@ -13,384 +13,384 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.RiskControl; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.RiskControlType; -import com.validation.manager.core.db.RiskItem; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.RiskControlHasTestCase; -import com.validation.manager.core.db.RiskControlHasRequirement; -import com.validation.manager.core.db.RiskControlPK; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RiskControlJpaController implements Serializable { - - public RiskControlJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(RiskControl riskControl) throws PreexistingEntityException, Exception { - if (riskControl.getRiskControlPK() == null) { - riskControl.setRiskControlPK(new RiskControlPK()); - } - if (riskControl.getRiskItemList() == null) { - riskControl.setRiskItemList(new ArrayList()); - } - if (riskControl.getRiskItemList1() == null) { - riskControl.setRiskItemList1(new ArrayList()); - } - if (riskControl.getRiskControlHasTestCaseList() == null) { - riskControl.setRiskControlHasTestCaseList(new ArrayList()); - } - if (riskControl.getRiskControlHasRequirementList() == null) { - riskControl.setRiskControlHasRequirementList(new ArrayList()); - } - riskControl.getRiskControlPK().setRiskControlTypeId(riskControl.getRiskControlType().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RiskControlType riskControlType = riskControl.getRiskControlType(); - if (riskControlType != null) { - riskControlType = em.getReference(riskControlType.getClass(), riskControlType.getId()); - riskControl.setRiskControlType(riskControlType); - } - List attachedRiskItemList = new ArrayList(); - for (RiskItem riskItemListRiskItemToAttach : riskControl.getRiskItemList()) { - riskItemListRiskItemToAttach = em.getReference(riskItemListRiskItemToAttach.getClass(), riskItemListRiskItemToAttach.getRiskItemPK()); - attachedRiskItemList.add(riskItemListRiskItemToAttach); - } - riskControl.setRiskItemList(attachedRiskItemList); - List attachedRiskItemList1 = new ArrayList(); - for (RiskItem riskItemList1RiskItemToAttach : riskControl.getRiskItemList1()) { - riskItemList1RiskItemToAttach = em.getReference(riskItemList1RiskItemToAttach.getClass(), riskItemList1RiskItemToAttach.getRiskItemPK()); - attachedRiskItemList1.add(riskItemList1RiskItemToAttach); - } - riskControl.setRiskItemList1(attachedRiskItemList1); - List attachedRiskControlHasTestCaseList = new ArrayList(); - for (RiskControlHasTestCase riskControlHasTestCaseListRiskControlHasTestCaseToAttach : riskControl.getRiskControlHasTestCaseList()) { - riskControlHasTestCaseListRiskControlHasTestCaseToAttach = em.getReference(riskControlHasTestCaseListRiskControlHasTestCaseToAttach.getClass(), riskControlHasTestCaseListRiskControlHasTestCaseToAttach.getRiskControlHasTestCasePK()); - attachedRiskControlHasTestCaseList.add(riskControlHasTestCaseListRiskControlHasTestCaseToAttach); - } - riskControl.setRiskControlHasTestCaseList(attachedRiskControlHasTestCaseList); - List attachedRiskControlHasRequirementList = new ArrayList(); - for (RiskControlHasRequirement riskControlHasRequirementListRiskControlHasRequirementToAttach : riskControl.getRiskControlHasRequirementList()) { - riskControlHasRequirementListRiskControlHasRequirementToAttach = em.getReference(riskControlHasRequirementListRiskControlHasRequirementToAttach.getClass(), riskControlHasRequirementListRiskControlHasRequirementToAttach.getRiskControlHasRequirementPK()); - attachedRiskControlHasRequirementList.add(riskControlHasRequirementListRiskControlHasRequirementToAttach); - } - riskControl.setRiskControlHasRequirementList(attachedRiskControlHasRequirementList); - em.persist(riskControl); - if (riskControlType != null) { - riskControlType.getRiskControlList().add(riskControl); - riskControlType = em.merge(riskControlType); - } - for (RiskItem riskItemListRiskItem : riskControl.getRiskItemList()) { - riskItemListRiskItem.getRiskControlList().add(riskControl); - riskItemListRiskItem = em.merge(riskItemListRiskItem); - } - for (RiskItem riskItemList1RiskItem : riskControl.getRiskItemList1()) { - riskItemList1RiskItem.getRiskControlList().add(riskControl); - riskItemList1RiskItem = em.merge(riskItemList1RiskItem); - } - for (RiskControlHasTestCase riskControlHasTestCaseListRiskControlHasTestCase : riskControl.getRiskControlHasTestCaseList()) { - RiskControl oldRiskControlOfRiskControlHasTestCaseListRiskControlHasTestCase = riskControlHasTestCaseListRiskControlHasTestCase.getRiskControl(); - riskControlHasTestCaseListRiskControlHasTestCase.setRiskControl(riskControl); - riskControlHasTestCaseListRiskControlHasTestCase = em.merge(riskControlHasTestCaseListRiskControlHasTestCase); - if (oldRiskControlOfRiskControlHasTestCaseListRiskControlHasTestCase != null) { - oldRiskControlOfRiskControlHasTestCaseListRiskControlHasTestCase.getRiskControlHasTestCaseList().remove(riskControlHasTestCaseListRiskControlHasTestCase); - oldRiskControlOfRiskControlHasTestCaseListRiskControlHasTestCase = em.merge(oldRiskControlOfRiskControlHasTestCaseListRiskControlHasTestCase); - } - } - for (RiskControlHasRequirement riskControlHasRequirementListRiskControlHasRequirement : riskControl.getRiskControlHasRequirementList()) { - RiskControl oldRiskControlOfRiskControlHasRequirementListRiskControlHasRequirement = riskControlHasRequirementListRiskControlHasRequirement.getRiskControl(); - riskControlHasRequirementListRiskControlHasRequirement.setRiskControl(riskControl); - riskControlHasRequirementListRiskControlHasRequirement = em.merge(riskControlHasRequirementListRiskControlHasRequirement); - if (oldRiskControlOfRiskControlHasRequirementListRiskControlHasRequirement != null) { - oldRiskControlOfRiskControlHasRequirementListRiskControlHasRequirement.getRiskControlHasRequirementList().remove(riskControlHasRequirementListRiskControlHasRequirement); - oldRiskControlOfRiskControlHasRequirementListRiskControlHasRequirement = em.merge(oldRiskControlOfRiskControlHasRequirementListRiskControlHasRequirement); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findRiskControl(riskControl.getRiskControlPK()) != null) { - throw new PreexistingEntityException("RiskControl " + riskControl + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(RiskControl riskControl) throws IllegalOrphanException, NonexistentEntityException, Exception { - riskControl.getRiskControlPK().setRiskControlTypeId(riskControl.getRiskControlType().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RiskControl persistentRiskControl = em.find(RiskControl.class, riskControl.getRiskControlPK()); - RiskControlType riskControlTypeOld = persistentRiskControl.getRiskControlType(); - RiskControlType riskControlTypeNew = riskControl.getRiskControlType(); - List riskItemListOld = persistentRiskControl.getRiskItemList(); - List riskItemListNew = riskControl.getRiskItemList(); - List riskItemList1Old = persistentRiskControl.getRiskItemList1(); - List riskItemList1New = riskControl.getRiskItemList1(); - List riskControlHasTestCaseListOld = persistentRiskControl.getRiskControlHasTestCaseList(); - List riskControlHasTestCaseListNew = riskControl.getRiskControlHasTestCaseList(); - List riskControlHasRequirementListOld = persistentRiskControl.getRiskControlHasRequirementList(); - List riskControlHasRequirementListNew = riskControl.getRiskControlHasRequirementList(); - List illegalOrphanMessages = null; - for (RiskControlHasTestCase riskControlHasTestCaseListOldRiskControlHasTestCase : riskControlHasTestCaseListOld) { - if (!riskControlHasTestCaseListNew.contains(riskControlHasTestCaseListOldRiskControlHasTestCase)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RiskControlHasTestCase " + riskControlHasTestCaseListOldRiskControlHasTestCase + " since its riskControl field is not nullable."); - } - } - for (RiskControlHasRequirement riskControlHasRequirementListOldRiskControlHasRequirement : riskControlHasRequirementListOld) { - if (!riskControlHasRequirementListNew.contains(riskControlHasRequirementListOldRiskControlHasRequirement)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RiskControlHasRequirement " + riskControlHasRequirementListOldRiskControlHasRequirement + " since its riskControl field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (riskControlTypeNew != null) { - riskControlTypeNew = em.getReference(riskControlTypeNew.getClass(), riskControlTypeNew.getId()); - riskControl.setRiskControlType(riskControlTypeNew); - } - List attachedRiskItemListNew = new ArrayList(); - for (RiskItem riskItemListNewRiskItemToAttach : riskItemListNew) { - riskItemListNewRiskItemToAttach = em.getReference(riskItemListNewRiskItemToAttach.getClass(), riskItemListNewRiskItemToAttach.getRiskItemPK()); - attachedRiskItemListNew.add(riskItemListNewRiskItemToAttach); - } - riskItemListNew = attachedRiskItemListNew; - riskControl.setRiskItemList(riskItemListNew); - List attachedRiskItemList1New = new ArrayList(); - for (RiskItem riskItemList1NewRiskItemToAttach : riskItemList1New) { - riskItemList1NewRiskItemToAttach = em.getReference(riskItemList1NewRiskItemToAttach.getClass(), riskItemList1NewRiskItemToAttach.getRiskItemPK()); - attachedRiskItemList1New.add(riskItemList1NewRiskItemToAttach); - } - riskItemList1New = attachedRiskItemList1New; - riskControl.setRiskItemList1(riskItemList1New); - List attachedRiskControlHasTestCaseListNew = new ArrayList(); - for (RiskControlHasTestCase riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach : riskControlHasTestCaseListNew) { - riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach = em.getReference(riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach.getClass(), riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach.getRiskControlHasTestCasePK()); - attachedRiskControlHasTestCaseListNew.add(riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach); - } - riskControlHasTestCaseListNew = attachedRiskControlHasTestCaseListNew; - riskControl.setRiskControlHasTestCaseList(riskControlHasTestCaseListNew); - List attachedRiskControlHasRequirementListNew = new ArrayList(); - for (RiskControlHasRequirement riskControlHasRequirementListNewRiskControlHasRequirementToAttach : riskControlHasRequirementListNew) { - riskControlHasRequirementListNewRiskControlHasRequirementToAttach = em.getReference(riskControlHasRequirementListNewRiskControlHasRequirementToAttach.getClass(), riskControlHasRequirementListNewRiskControlHasRequirementToAttach.getRiskControlHasRequirementPK()); - attachedRiskControlHasRequirementListNew.add(riskControlHasRequirementListNewRiskControlHasRequirementToAttach); - } - riskControlHasRequirementListNew = attachedRiskControlHasRequirementListNew; - riskControl.setRiskControlHasRequirementList(riskControlHasRequirementListNew); - riskControl = em.merge(riskControl); - if (riskControlTypeOld != null && !riskControlTypeOld.equals(riskControlTypeNew)) { - riskControlTypeOld.getRiskControlList().remove(riskControl); - riskControlTypeOld = em.merge(riskControlTypeOld); - } - if (riskControlTypeNew != null && !riskControlTypeNew.equals(riskControlTypeOld)) { - riskControlTypeNew.getRiskControlList().add(riskControl); - riskControlTypeNew = em.merge(riskControlTypeNew); - } - for (RiskItem riskItemListOldRiskItem : riskItemListOld) { - if (!riskItemListNew.contains(riskItemListOldRiskItem)) { - riskItemListOldRiskItem.getRiskControlList().remove(riskControl); - riskItemListOldRiskItem = em.merge(riskItemListOldRiskItem); - } - } - for (RiskItem riskItemListNewRiskItem : riskItemListNew) { - if (!riskItemListOld.contains(riskItemListNewRiskItem)) { - riskItemListNewRiskItem.getRiskControlList().add(riskControl); - riskItemListNewRiskItem = em.merge(riskItemListNewRiskItem); - } - } - for (RiskItem riskItemList1OldRiskItem : riskItemList1Old) { - if (!riskItemList1New.contains(riskItemList1OldRiskItem)) { - riskItemList1OldRiskItem.getRiskControlList().remove(riskControl); - riskItemList1OldRiskItem = em.merge(riskItemList1OldRiskItem); - } - } - for (RiskItem riskItemList1NewRiskItem : riskItemList1New) { - if (!riskItemList1Old.contains(riskItemList1NewRiskItem)) { - riskItemList1NewRiskItem.getRiskControlList().add(riskControl); - riskItemList1NewRiskItem = em.merge(riskItemList1NewRiskItem); - } - } - for (RiskControlHasTestCase riskControlHasTestCaseListNewRiskControlHasTestCase : riskControlHasTestCaseListNew) { - if (!riskControlHasTestCaseListOld.contains(riskControlHasTestCaseListNewRiskControlHasTestCase)) { - RiskControl oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase = riskControlHasTestCaseListNewRiskControlHasTestCase.getRiskControl(); - riskControlHasTestCaseListNewRiskControlHasTestCase.setRiskControl(riskControl); - riskControlHasTestCaseListNewRiskControlHasTestCase = em.merge(riskControlHasTestCaseListNewRiskControlHasTestCase); - if (oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase != null && !oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase.equals(riskControl)) { - oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase.getRiskControlHasTestCaseList().remove(riskControlHasTestCaseListNewRiskControlHasTestCase); - oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase = em.merge(oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase); - } - } - } - for (RiskControlHasRequirement riskControlHasRequirementListNewRiskControlHasRequirement : riskControlHasRequirementListNew) { - if (!riskControlHasRequirementListOld.contains(riskControlHasRequirementListNewRiskControlHasRequirement)) { - RiskControl oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement = riskControlHasRequirementListNewRiskControlHasRequirement.getRiskControl(); - riskControlHasRequirementListNewRiskControlHasRequirement.setRiskControl(riskControl); - riskControlHasRequirementListNewRiskControlHasRequirement = em.merge(riskControlHasRequirementListNewRiskControlHasRequirement); - if (oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement != null && !oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement.equals(riskControl)) { - oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement.getRiskControlHasRequirementList().remove(riskControlHasRequirementListNewRiskControlHasRequirement); - oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement = em.merge(oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - RiskControlPK id = riskControl.getRiskControlPK(); - if (findRiskControl(id) == null) { - throw new NonexistentEntityException("The riskControl with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(RiskControlPK id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RiskControl riskControl; - try { - riskControl = em.getReference(RiskControl.class, id); - riskControl.getRiskControlPK(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The riskControl with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List riskControlHasTestCaseListOrphanCheck = riskControl.getRiskControlHasTestCaseList(); - for (RiskControlHasTestCase riskControlHasTestCaseListOrphanCheckRiskControlHasTestCase : riskControlHasTestCaseListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RiskControl (" + riskControl + ") cannot be destroyed since the RiskControlHasTestCase " + riskControlHasTestCaseListOrphanCheckRiskControlHasTestCase + " in its riskControlHasTestCaseList field has a non-nullable riskControl field."); - } - List riskControlHasRequirementListOrphanCheck = riskControl.getRiskControlHasRequirementList(); - for (RiskControlHasRequirement riskControlHasRequirementListOrphanCheckRiskControlHasRequirement : riskControlHasRequirementListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RiskControl (" + riskControl + ") cannot be destroyed since the RiskControlHasRequirement " + riskControlHasRequirementListOrphanCheckRiskControlHasRequirement + " in its riskControlHasRequirementList field has a non-nullable riskControl field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - RiskControlType riskControlType = riskControl.getRiskControlType(); - if (riskControlType != null) { - riskControlType.getRiskControlList().remove(riskControl); - riskControlType = em.merge(riskControlType); - } - List riskItemList = riskControl.getRiskItemList(); - for (RiskItem riskItemListRiskItem : riskItemList) { - riskItemListRiskItem.getRiskControlList().remove(riskControl); - riskItemListRiskItem = em.merge(riskItemListRiskItem); - } - List riskItemList1 = riskControl.getRiskItemList1(); - for (RiskItem riskItemList1RiskItem : riskItemList1) { - riskItemList1RiskItem.getRiskControlList().remove(riskControl); - riskItemList1RiskItem = em.merge(riskItemList1RiskItem); - } - em.remove(riskControl); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRiskControlEntities() { - return findRiskControlEntities(true, -1, -1); - } - - public List findRiskControlEntities(int maxResults, int firstResult) { - return findRiskControlEntities(false, maxResults, firstResult); - } - - private List findRiskControlEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(RiskControl.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public RiskControl findRiskControl(RiskControlPK id) { - EntityManager em = getEntityManager(); - try { - return em.find(RiskControl.class, id); - } - finally { - em.close(); - } - } - - public int getRiskControlCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(RiskControl.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.RiskControl; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.RiskControlType; +import com.validation.manager.core.db.RiskItem; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.RiskControlHasTestCase; +import com.validation.manager.core.db.RiskControlHasRequirement; +import com.validation.manager.core.db.RiskControlPK; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RiskControlJpaController implements Serializable { + + public RiskControlJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(RiskControl riskControl) throws PreexistingEntityException, Exception { + if (riskControl.getRiskControlPK() == null) { + riskControl.setRiskControlPK(new RiskControlPK()); + } + if (riskControl.getRiskItemList() == null) { + riskControl.setRiskItemList(new ArrayList<>()); + } + if (riskControl.getRiskItemList1() == null) { + riskControl.setRiskItemList1(new ArrayList<>()); + } + if (riskControl.getRiskControlHasTestCaseList() == null) { + riskControl.setRiskControlHasTestCaseList(new ArrayList<>()); + } + if (riskControl.getRiskControlHasRequirementList() == null) { + riskControl.setRiskControlHasRequirementList(new ArrayList<>()); + } + riskControl.getRiskControlPK().setRiskControlTypeId(riskControl.getRiskControlType().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RiskControlType riskControlType = riskControl.getRiskControlType(); + if (riskControlType != null) { + riskControlType = em.getReference(riskControlType.getClass(), riskControlType.getId()); + riskControl.setRiskControlType(riskControlType); + } + List attachedRiskItemList = new ArrayList<>(); + for (RiskItem riskItemListRiskItemToAttach : riskControl.getRiskItemList()) { + riskItemListRiskItemToAttach = em.getReference(riskItemListRiskItemToAttach.getClass(), riskItemListRiskItemToAttach.getRiskItemPK()); + attachedRiskItemList.add(riskItemListRiskItemToAttach); + } + riskControl.setRiskItemList(attachedRiskItemList); + List attachedRiskItemList1 = new ArrayList<>(); + for (RiskItem riskItemList1RiskItemToAttach : riskControl.getRiskItemList1()) { + riskItemList1RiskItemToAttach = em.getReference(riskItemList1RiskItemToAttach.getClass(), riskItemList1RiskItemToAttach.getRiskItemPK()); + attachedRiskItemList1.add(riskItemList1RiskItemToAttach); + } + riskControl.setRiskItemList1(attachedRiskItemList1); + List attachedRiskControlHasTestCaseList = new ArrayList<>(); + for (RiskControlHasTestCase riskControlHasTestCaseListRiskControlHasTestCaseToAttach : riskControl.getRiskControlHasTestCaseList()) { + riskControlHasTestCaseListRiskControlHasTestCaseToAttach = em.getReference(riskControlHasTestCaseListRiskControlHasTestCaseToAttach.getClass(), riskControlHasTestCaseListRiskControlHasTestCaseToAttach.getRiskControlHasTestCasePK()); + attachedRiskControlHasTestCaseList.add(riskControlHasTestCaseListRiskControlHasTestCaseToAttach); + } + riskControl.setRiskControlHasTestCaseList(attachedRiskControlHasTestCaseList); + List attachedRiskControlHasRequirementList = new ArrayList<>(); + for (RiskControlHasRequirement riskControlHasRequirementListRiskControlHasRequirementToAttach : riskControl.getRiskControlHasRequirementList()) { + riskControlHasRequirementListRiskControlHasRequirementToAttach = em.getReference(riskControlHasRequirementListRiskControlHasRequirementToAttach.getClass(), riskControlHasRequirementListRiskControlHasRequirementToAttach.getRiskControlHasRequirementPK()); + attachedRiskControlHasRequirementList.add(riskControlHasRequirementListRiskControlHasRequirementToAttach); + } + riskControl.setRiskControlHasRequirementList(attachedRiskControlHasRequirementList); + em.persist(riskControl); + if (riskControlType != null) { + riskControlType.getRiskControlList().add(riskControl); + riskControlType = em.merge(riskControlType); + } + for (RiskItem riskItemListRiskItem : riskControl.getRiskItemList()) { + riskItemListRiskItem.getRiskControlList().add(riskControl); + riskItemListRiskItem = em.merge(riskItemListRiskItem); + } + for (RiskItem riskItemList1RiskItem : riskControl.getRiskItemList1()) { + riskItemList1RiskItem.getRiskControlList().add(riskControl); + riskItemList1RiskItem = em.merge(riskItemList1RiskItem); + } + for (RiskControlHasTestCase riskControlHasTestCaseListRiskControlHasTestCase : riskControl.getRiskControlHasTestCaseList()) { + RiskControl oldRiskControlOfRiskControlHasTestCaseListRiskControlHasTestCase = riskControlHasTestCaseListRiskControlHasTestCase.getRiskControl(); + riskControlHasTestCaseListRiskControlHasTestCase.setRiskControl(riskControl); + riskControlHasTestCaseListRiskControlHasTestCase = em.merge(riskControlHasTestCaseListRiskControlHasTestCase); + if (oldRiskControlOfRiskControlHasTestCaseListRiskControlHasTestCase != null) { + oldRiskControlOfRiskControlHasTestCaseListRiskControlHasTestCase.getRiskControlHasTestCaseList().remove(riskControlHasTestCaseListRiskControlHasTestCase); + oldRiskControlOfRiskControlHasTestCaseListRiskControlHasTestCase = em.merge(oldRiskControlOfRiskControlHasTestCaseListRiskControlHasTestCase); + } + } + for (RiskControlHasRequirement riskControlHasRequirementListRiskControlHasRequirement : riskControl.getRiskControlHasRequirementList()) { + RiskControl oldRiskControlOfRiskControlHasRequirementListRiskControlHasRequirement = riskControlHasRequirementListRiskControlHasRequirement.getRiskControl(); + riskControlHasRequirementListRiskControlHasRequirement.setRiskControl(riskControl); + riskControlHasRequirementListRiskControlHasRequirement = em.merge(riskControlHasRequirementListRiskControlHasRequirement); + if (oldRiskControlOfRiskControlHasRequirementListRiskControlHasRequirement != null) { + oldRiskControlOfRiskControlHasRequirementListRiskControlHasRequirement.getRiskControlHasRequirementList().remove(riskControlHasRequirementListRiskControlHasRequirement); + oldRiskControlOfRiskControlHasRequirementListRiskControlHasRequirement = em.merge(oldRiskControlOfRiskControlHasRequirementListRiskControlHasRequirement); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findRiskControl(riskControl.getRiskControlPK()) != null) { + throw new PreexistingEntityException("RiskControl " + riskControl + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(RiskControl riskControl) throws IllegalOrphanException, NonexistentEntityException, Exception { + riskControl.getRiskControlPK().setRiskControlTypeId(riskControl.getRiskControlType().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RiskControl persistentRiskControl = em.find(RiskControl.class, riskControl.getRiskControlPK()); + RiskControlType riskControlTypeOld = persistentRiskControl.getRiskControlType(); + RiskControlType riskControlTypeNew = riskControl.getRiskControlType(); + List riskItemListOld = persistentRiskControl.getRiskItemList(); + List riskItemListNew = riskControl.getRiskItemList(); + List riskItemList1Old = persistentRiskControl.getRiskItemList1(); + List riskItemList1New = riskControl.getRiskItemList1(); + List riskControlHasTestCaseListOld = persistentRiskControl.getRiskControlHasTestCaseList(); + List riskControlHasTestCaseListNew = riskControl.getRiskControlHasTestCaseList(); + List riskControlHasRequirementListOld = persistentRiskControl.getRiskControlHasRequirementList(); + List riskControlHasRequirementListNew = riskControl.getRiskControlHasRequirementList(); + List illegalOrphanMessages = null; + for (RiskControlHasTestCase riskControlHasTestCaseListOldRiskControlHasTestCase : riskControlHasTestCaseListOld) { + if (!riskControlHasTestCaseListNew.contains(riskControlHasTestCaseListOldRiskControlHasTestCase)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RiskControlHasTestCase " + riskControlHasTestCaseListOldRiskControlHasTestCase + " since its riskControl field is not nullable."); + } + } + for (RiskControlHasRequirement riskControlHasRequirementListOldRiskControlHasRequirement : riskControlHasRequirementListOld) { + if (!riskControlHasRequirementListNew.contains(riskControlHasRequirementListOldRiskControlHasRequirement)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RiskControlHasRequirement " + riskControlHasRequirementListOldRiskControlHasRequirement + " since its riskControl field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (riskControlTypeNew != null) { + riskControlTypeNew = em.getReference(riskControlTypeNew.getClass(), riskControlTypeNew.getId()); + riskControl.setRiskControlType(riskControlTypeNew); + } + List attachedRiskItemListNew = new ArrayList<>(); + for (RiskItem riskItemListNewRiskItemToAttach : riskItemListNew) { + riskItemListNewRiskItemToAttach = em.getReference(riskItemListNewRiskItemToAttach.getClass(), riskItemListNewRiskItemToAttach.getRiskItemPK()); + attachedRiskItemListNew.add(riskItemListNewRiskItemToAttach); + } + riskItemListNew = attachedRiskItemListNew; + riskControl.setRiskItemList(riskItemListNew); + List attachedRiskItemList1New = new ArrayList<>(); + for (RiskItem riskItemList1NewRiskItemToAttach : riskItemList1New) { + riskItemList1NewRiskItemToAttach = em.getReference(riskItemList1NewRiskItemToAttach.getClass(), riskItemList1NewRiskItemToAttach.getRiskItemPK()); + attachedRiskItemList1New.add(riskItemList1NewRiskItemToAttach); + } + riskItemList1New = attachedRiskItemList1New; + riskControl.setRiskItemList1(riskItemList1New); + List attachedRiskControlHasTestCaseListNew = new ArrayList<>(); + for (RiskControlHasTestCase riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach : riskControlHasTestCaseListNew) { + riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach = em.getReference(riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach.getClass(), riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach.getRiskControlHasTestCasePK()); + attachedRiskControlHasTestCaseListNew.add(riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach); + } + riskControlHasTestCaseListNew = attachedRiskControlHasTestCaseListNew; + riskControl.setRiskControlHasTestCaseList(riskControlHasTestCaseListNew); + List attachedRiskControlHasRequirementListNew = new ArrayList<>(); + for (RiskControlHasRequirement riskControlHasRequirementListNewRiskControlHasRequirementToAttach : riskControlHasRequirementListNew) { + riskControlHasRequirementListNewRiskControlHasRequirementToAttach = em.getReference(riskControlHasRequirementListNewRiskControlHasRequirementToAttach.getClass(), riskControlHasRequirementListNewRiskControlHasRequirementToAttach.getRiskControlHasRequirementPK()); + attachedRiskControlHasRequirementListNew.add(riskControlHasRequirementListNewRiskControlHasRequirementToAttach); + } + riskControlHasRequirementListNew = attachedRiskControlHasRequirementListNew; + riskControl.setRiskControlHasRequirementList(riskControlHasRequirementListNew); + riskControl = em.merge(riskControl); + if (riskControlTypeOld != null && !riskControlTypeOld.equals(riskControlTypeNew)) { + riskControlTypeOld.getRiskControlList().remove(riskControl); + riskControlTypeOld = em.merge(riskControlTypeOld); + } + if (riskControlTypeNew != null && !riskControlTypeNew.equals(riskControlTypeOld)) { + riskControlTypeNew.getRiskControlList().add(riskControl); + riskControlTypeNew = em.merge(riskControlTypeNew); + } + for (RiskItem riskItemListOldRiskItem : riskItemListOld) { + if (!riskItemListNew.contains(riskItemListOldRiskItem)) { + riskItemListOldRiskItem.getRiskControlList().remove(riskControl); + riskItemListOldRiskItem = em.merge(riskItemListOldRiskItem); + } + } + for (RiskItem riskItemListNewRiskItem : riskItemListNew) { + if (!riskItemListOld.contains(riskItemListNewRiskItem)) { + riskItemListNewRiskItem.getRiskControlList().add(riskControl); + riskItemListNewRiskItem = em.merge(riskItemListNewRiskItem); + } + } + for (RiskItem riskItemList1OldRiskItem : riskItemList1Old) { + if (!riskItemList1New.contains(riskItemList1OldRiskItem)) { + riskItemList1OldRiskItem.getRiskControlList().remove(riskControl); + riskItemList1OldRiskItem = em.merge(riskItemList1OldRiskItem); + } + } + for (RiskItem riskItemList1NewRiskItem : riskItemList1New) { + if (!riskItemList1Old.contains(riskItemList1NewRiskItem)) { + riskItemList1NewRiskItem.getRiskControlList().add(riskControl); + riskItemList1NewRiskItem = em.merge(riskItemList1NewRiskItem); + } + } + for (RiskControlHasTestCase riskControlHasTestCaseListNewRiskControlHasTestCase : riskControlHasTestCaseListNew) { + if (!riskControlHasTestCaseListOld.contains(riskControlHasTestCaseListNewRiskControlHasTestCase)) { + RiskControl oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase = riskControlHasTestCaseListNewRiskControlHasTestCase.getRiskControl(); + riskControlHasTestCaseListNewRiskControlHasTestCase.setRiskControl(riskControl); + riskControlHasTestCaseListNewRiskControlHasTestCase = em.merge(riskControlHasTestCaseListNewRiskControlHasTestCase); + if (oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase != null && !oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase.equals(riskControl)) { + oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase.getRiskControlHasTestCaseList().remove(riskControlHasTestCaseListNewRiskControlHasTestCase); + oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase = em.merge(oldRiskControlOfRiskControlHasTestCaseListNewRiskControlHasTestCase); + } + } + } + for (RiskControlHasRequirement riskControlHasRequirementListNewRiskControlHasRequirement : riskControlHasRequirementListNew) { + if (!riskControlHasRequirementListOld.contains(riskControlHasRequirementListNewRiskControlHasRequirement)) { + RiskControl oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement = riskControlHasRequirementListNewRiskControlHasRequirement.getRiskControl(); + riskControlHasRequirementListNewRiskControlHasRequirement.setRiskControl(riskControl); + riskControlHasRequirementListNewRiskControlHasRequirement = em.merge(riskControlHasRequirementListNewRiskControlHasRequirement); + if (oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement != null && !oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement.equals(riskControl)) { + oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement.getRiskControlHasRequirementList().remove(riskControlHasRequirementListNewRiskControlHasRequirement); + oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement = em.merge(oldRiskControlOfRiskControlHasRequirementListNewRiskControlHasRequirement); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + RiskControlPK id = riskControl.getRiskControlPK(); + if (findRiskControl(id) == null) { + throw new NonexistentEntityException("The riskControl with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(RiskControlPK id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RiskControl riskControl; + try { + riskControl = em.getReference(RiskControl.class, id); + riskControl.getRiskControlPK(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The riskControl with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List riskControlHasTestCaseListOrphanCheck = riskControl.getRiskControlHasTestCaseList(); + for (RiskControlHasTestCase riskControlHasTestCaseListOrphanCheckRiskControlHasTestCase : riskControlHasTestCaseListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RiskControl (" + riskControl + ") cannot be destroyed since the RiskControlHasTestCase " + riskControlHasTestCaseListOrphanCheckRiskControlHasTestCase + " in its riskControlHasTestCaseList field has a non-nullable riskControl field."); + } + List riskControlHasRequirementListOrphanCheck = riskControl.getRiskControlHasRequirementList(); + for (RiskControlHasRequirement riskControlHasRequirementListOrphanCheckRiskControlHasRequirement : riskControlHasRequirementListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RiskControl (" + riskControl + ") cannot be destroyed since the RiskControlHasRequirement " + riskControlHasRequirementListOrphanCheckRiskControlHasRequirement + " in its riskControlHasRequirementList field has a non-nullable riskControl field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + RiskControlType riskControlType = riskControl.getRiskControlType(); + if (riskControlType != null) { + riskControlType.getRiskControlList().remove(riskControl); + riskControlType = em.merge(riskControlType); + } + List riskItemList = riskControl.getRiskItemList(); + for (RiskItem riskItemListRiskItem : riskItemList) { + riskItemListRiskItem.getRiskControlList().remove(riskControl); + riskItemListRiskItem = em.merge(riskItemListRiskItem); + } + List riskItemList1 = riskControl.getRiskItemList1(); + for (RiskItem riskItemList1RiskItem : riskItemList1) { + riskItemList1RiskItem.getRiskControlList().remove(riskControl); + riskItemList1RiskItem = em.merge(riskItemList1RiskItem); + } + em.remove(riskControl); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRiskControlEntities() { + return findRiskControlEntities(true, -1, -1); + } + + public List findRiskControlEntities(int maxResults, int firstResult) { + return findRiskControlEntities(false, maxResults, firstResult); + } + + private List findRiskControlEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(RiskControl.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public RiskControl findRiskControl(RiskControlPK id) { + EntityManager em = getEntityManager(); + try { + return em.find(RiskControl.class, id); + } + finally { + em.close(); + } + } + + public int getRiskControlCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(RiskControl.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskControlTypeJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskControlTypeJpaController.java index 859776db..a0b0f18e 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskControlTypeJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskControlTypeJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.RiskControl; -import com.validation.manager.core.db.RiskControlType; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RiskControlTypeJpaController implements Serializable { - - public RiskControlTypeJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(RiskControlType riskControlType) { - if (riskControlType.getRiskControlList() == null) { - riskControlType.setRiskControlList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedRiskControlList = new ArrayList(); - for (RiskControl riskControlListRiskControlToAttach : riskControlType.getRiskControlList()) { - riskControlListRiskControlToAttach = em.getReference(riskControlListRiskControlToAttach.getClass(), riskControlListRiskControlToAttach.getRiskControlPK()); - attachedRiskControlList.add(riskControlListRiskControlToAttach); - } - riskControlType.setRiskControlList(attachedRiskControlList); - em.persist(riskControlType); - for (RiskControl riskControlListRiskControl : riskControlType.getRiskControlList()) { - RiskControlType oldRiskControlTypeOfRiskControlListRiskControl = riskControlListRiskControl.getRiskControlType(); - riskControlListRiskControl.setRiskControlType(riskControlType); - riskControlListRiskControl = em.merge(riskControlListRiskControl); - if (oldRiskControlTypeOfRiskControlListRiskControl != null) { - oldRiskControlTypeOfRiskControlListRiskControl.getRiskControlList().remove(riskControlListRiskControl); - oldRiskControlTypeOfRiskControlListRiskControl = em.merge(oldRiskControlTypeOfRiskControlListRiskControl); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(RiskControlType riskControlType) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RiskControlType persistentRiskControlType = em.find(RiskControlType.class, riskControlType.getId()); - List riskControlListOld = persistentRiskControlType.getRiskControlList(); - List riskControlListNew = riskControlType.getRiskControlList(); - List illegalOrphanMessages = null; - for (RiskControl riskControlListOldRiskControl : riskControlListOld) { - if (!riskControlListNew.contains(riskControlListOldRiskControl)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RiskControl " + riskControlListOldRiskControl + " since its riskControlType field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedRiskControlListNew = new ArrayList(); - for (RiskControl riskControlListNewRiskControlToAttach : riskControlListNew) { - riskControlListNewRiskControlToAttach = em.getReference(riskControlListNewRiskControlToAttach.getClass(), riskControlListNewRiskControlToAttach.getRiskControlPK()); - attachedRiskControlListNew.add(riskControlListNewRiskControlToAttach); - } - riskControlListNew = attachedRiskControlListNew; - riskControlType.setRiskControlList(riskControlListNew); - riskControlType = em.merge(riskControlType); - for (RiskControl riskControlListNewRiskControl : riskControlListNew) { - if (!riskControlListOld.contains(riskControlListNewRiskControl)) { - RiskControlType oldRiskControlTypeOfRiskControlListNewRiskControl = riskControlListNewRiskControl.getRiskControlType(); - riskControlListNewRiskControl.setRiskControlType(riskControlType); - riskControlListNewRiskControl = em.merge(riskControlListNewRiskControl); - if (oldRiskControlTypeOfRiskControlListNewRiskControl != null && !oldRiskControlTypeOfRiskControlListNewRiskControl.equals(riskControlType)) { - oldRiskControlTypeOfRiskControlListNewRiskControl.getRiskControlList().remove(riskControlListNewRiskControl); - oldRiskControlTypeOfRiskControlListNewRiskControl = em.merge(oldRiskControlTypeOfRiskControlListNewRiskControl); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = riskControlType.getId(); - if (findRiskControlType(id) == null) { - throw new NonexistentEntityException("The riskControlType with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RiskControlType riskControlType; - try { - riskControlType = em.getReference(RiskControlType.class, id); - riskControlType.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The riskControlType with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List riskControlListOrphanCheck = riskControlType.getRiskControlList(); - for (RiskControl riskControlListOrphanCheckRiskControl : riskControlListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RiskControlType (" + riskControlType + ") cannot be destroyed since the RiskControl " + riskControlListOrphanCheckRiskControl + " in its riskControlList field has a non-nullable riskControlType field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(riskControlType); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRiskControlTypeEntities() { - return findRiskControlTypeEntities(true, -1, -1); - } - - public List findRiskControlTypeEntities(int maxResults, int firstResult) { - return findRiskControlTypeEntities(false, maxResults, firstResult); - } - - private List findRiskControlTypeEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(RiskControlType.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public RiskControlType findRiskControlType(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(RiskControlType.class, id); - } - finally { - em.close(); - } - } - - public int getRiskControlTypeCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(RiskControlType.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.RiskControl; +import com.validation.manager.core.db.RiskControlType; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RiskControlTypeJpaController implements Serializable { + + public RiskControlTypeJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(RiskControlType riskControlType) { + if (riskControlType.getRiskControlList() == null) { + riskControlType.setRiskControlList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedRiskControlList = new ArrayList<>(); + for (RiskControl riskControlListRiskControlToAttach : riskControlType.getRiskControlList()) { + riskControlListRiskControlToAttach = em.getReference(riskControlListRiskControlToAttach.getClass(), riskControlListRiskControlToAttach.getRiskControlPK()); + attachedRiskControlList.add(riskControlListRiskControlToAttach); + } + riskControlType.setRiskControlList(attachedRiskControlList); + em.persist(riskControlType); + for (RiskControl riskControlListRiskControl : riskControlType.getRiskControlList()) { + RiskControlType oldRiskControlTypeOfRiskControlListRiskControl = riskControlListRiskControl.getRiskControlType(); + riskControlListRiskControl.setRiskControlType(riskControlType); + riskControlListRiskControl = em.merge(riskControlListRiskControl); + if (oldRiskControlTypeOfRiskControlListRiskControl != null) { + oldRiskControlTypeOfRiskControlListRiskControl.getRiskControlList().remove(riskControlListRiskControl); + oldRiskControlTypeOfRiskControlListRiskControl = em.merge(oldRiskControlTypeOfRiskControlListRiskControl); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(RiskControlType riskControlType) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RiskControlType persistentRiskControlType = em.find(RiskControlType.class, riskControlType.getId()); + List riskControlListOld = persistentRiskControlType.getRiskControlList(); + List riskControlListNew = riskControlType.getRiskControlList(); + List illegalOrphanMessages = null; + for (RiskControl riskControlListOldRiskControl : riskControlListOld) { + if (!riskControlListNew.contains(riskControlListOldRiskControl)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RiskControl " + riskControlListOldRiskControl + " since its riskControlType field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedRiskControlListNew = new ArrayList<>(); + for (RiskControl riskControlListNewRiskControlToAttach : riskControlListNew) { + riskControlListNewRiskControlToAttach = em.getReference(riskControlListNewRiskControlToAttach.getClass(), riskControlListNewRiskControlToAttach.getRiskControlPK()); + attachedRiskControlListNew.add(riskControlListNewRiskControlToAttach); + } + riskControlListNew = attachedRiskControlListNew; + riskControlType.setRiskControlList(riskControlListNew); + riskControlType = em.merge(riskControlType); + for (RiskControl riskControlListNewRiskControl : riskControlListNew) { + if (!riskControlListOld.contains(riskControlListNewRiskControl)) { + RiskControlType oldRiskControlTypeOfRiskControlListNewRiskControl = riskControlListNewRiskControl.getRiskControlType(); + riskControlListNewRiskControl.setRiskControlType(riskControlType); + riskControlListNewRiskControl = em.merge(riskControlListNewRiskControl); + if (oldRiskControlTypeOfRiskControlListNewRiskControl != null && !oldRiskControlTypeOfRiskControlListNewRiskControl.equals(riskControlType)) { + oldRiskControlTypeOfRiskControlListNewRiskControl.getRiskControlList().remove(riskControlListNewRiskControl); + oldRiskControlTypeOfRiskControlListNewRiskControl = em.merge(oldRiskControlTypeOfRiskControlListNewRiskControl); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = riskControlType.getId(); + if (findRiskControlType(id) == null) { + throw new NonexistentEntityException("The riskControlType with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RiskControlType riskControlType; + try { + riskControlType = em.getReference(RiskControlType.class, id); + riskControlType.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The riskControlType with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List riskControlListOrphanCheck = riskControlType.getRiskControlList(); + for (RiskControl riskControlListOrphanCheckRiskControl : riskControlListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RiskControlType (" + riskControlType + ") cannot be destroyed since the RiskControl " + riskControlListOrphanCheckRiskControl + " in its riskControlList field has a non-nullable riskControlType field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(riskControlType); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRiskControlTypeEntities() { + return findRiskControlTypeEntities(true, -1, -1); + } + + public List findRiskControlTypeEntities(int maxResults, int firstResult) { + return findRiskControlTypeEntities(false, maxResults, firstResult); + } + + private List findRiskControlTypeEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(RiskControlType.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public RiskControlType findRiskControlType(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(RiskControlType.class, id); + } + finally { + em.close(); + } + } + + public int getRiskControlTypeCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(RiskControlType.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskItemJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskItemJpaController.java index 71e5fdc3..6e09afa5 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskItemJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RiskItemJpaController.java @@ -13,450 +13,450 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Fmea; -import com.validation.manager.core.db.FailureMode; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.Hazard; -import com.validation.manager.core.db.RiskControl; -import com.validation.manager.core.db.Cause; -import com.validation.manager.core.db.RiskItem; -import com.validation.manager.core.db.RiskItemHasRiskCategory; -import com.validation.manager.core.db.RiskItemPK; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RiskItemJpaController implements Serializable { - - public RiskItemJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(RiskItem riskItem) throws PreexistingEntityException, Exception { - if (riskItem.getRiskItemPK() == null) { - riskItem.setRiskItemPK(new RiskItemPK()); - } - if (riskItem.getFailureModeList() == null) { - riskItem.setFailureModeList(new ArrayList()); - } - if (riskItem.getHazardList() == null) { - riskItem.setHazardList(new ArrayList()); - } - if (riskItem.getRiskControlList() == null) { - riskItem.setRiskControlList(new ArrayList()); - } - if (riskItem.getRiskControlList1() == null) { - riskItem.setRiskControlList1(new ArrayList()); - } - if (riskItem.getCauseList() == null) { - riskItem.setCauseList(new ArrayList()); - } - if (riskItem.getRiskItemHasRiskCategoryList() == null) { - riskItem.setRiskItemHasRiskCategoryList(new ArrayList()); - } - riskItem.getRiskItemPK().setFMEAid(riskItem.getFmea().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Fmea fmea = riskItem.getFmea(); - if (fmea != null) { - fmea = em.getReference(fmea.getClass(), fmea.getId()); - riskItem.setFmea(fmea); - } - List attachedFailureModeList = new ArrayList(); - for (FailureMode failureModeListFailureModeToAttach : riskItem.getFailureModeList()) { - failureModeListFailureModeToAttach = em.getReference(failureModeListFailureModeToAttach.getClass(), failureModeListFailureModeToAttach.getId()); - attachedFailureModeList.add(failureModeListFailureModeToAttach); - } - riskItem.setFailureModeList(attachedFailureModeList); - List attachedHazardList = new ArrayList(); - for (Hazard hazardListHazardToAttach : riskItem.getHazardList()) { - hazardListHazardToAttach = em.getReference(hazardListHazardToAttach.getClass(), hazardListHazardToAttach.getId()); - attachedHazardList.add(hazardListHazardToAttach); - } - riskItem.setHazardList(attachedHazardList); - List attachedRiskControlList = new ArrayList(); - for (RiskControl riskControlListRiskControlToAttach : riskItem.getRiskControlList()) { - riskControlListRiskControlToAttach = em.getReference(riskControlListRiskControlToAttach.getClass(), riskControlListRiskControlToAttach.getRiskControlPK()); - attachedRiskControlList.add(riskControlListRiskControlToAttach); - } - riskItem.setRiskControlList(attachedRiskControlList); - List attachedRiskControlList1 = new ArrayList(); - for (RiskControl riskControlList1RiskControlToAttach : riskItem.getRiskControlList1()) { - riskControlList1RiskControlToAttach = em.getReference(riskControlList1RiskControlToAttach.getClass(), riskControlList1RiskControlToAttach.getRiskControlPK()); - attachedRiskControlList1.add(riskControlList1RiskControlToAttach); - } - riskItem.setRiskControlList1(attachedRiskControlList1); - List attachedCauseList = new ArrayList(); - for (Cause causeListCauseToAttach : riskItem.getCauseList()) { - causeListCauseToAttach = em.getReference(causeListCauseToAttach.getClass(), causeListCauseToAttach.getId()); - attachedCauseList.add(causeListCauseToAttach); - } - riskItem.setCauseList(attachedCauseList); - List attachedRiskItemHasRiskCategoryList = new ArrayList(); - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach : riskItem.getRiskItemHasRiskCategoryList()) { - riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach = em.getReference(riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach.getClass(), riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach.getRiskItemHasRiskCategoryPK()); - attachedRiskItemHasRiskCategoryList.add(riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach); - } - riskItem.setRiskItemHasRiskCategoryList(attachedRiskItemHasRiskCategoryList); - em.persist(riskItem); - if (fmea != null) { - fmea.getRiskItemList().add(riskItem); - fmea = em.merge(fmea); - } - for (FailureMode failureModeListFailureMode : riskItem.getFailureModeList()) { - failureModeListFailureMode.getRiskItemList().add(riskItem); - failureModeListFailureMode = em.merge(failureModeListFailureMode); - } - for (Hazard hazardListHazard : riskItem.getHazardList()) { - hazardListHazard.getRiskItemList().add(riskItem); - hazardListHazard = em.merge(hazardListHazard); - } - for (RiskControl riskControlListRiskControl : riskItem.getRiskControlList()) { - riskControlListRiskControl.getRiskItemList().add(riskItem); - riskControlListRiskControl = em.merge(riskControlListRiskControl); - } - for (RiskControl riskControlList1RiskControl : riskItem.getRiskControlList1()) { - riskControlList1RiskControl.getRiskItemList1().add(riskItem); - riskControlList1RiskControl = em.merge(riskControlList1RiskControl); - } - for (Cause causeListCause : riskItem.getCauseList()) { - causeListCause.getRiskItemList().add(riskItem); - causeListCause = em.merge(causeListCause); - } - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListRiskItemHasRiskCategory : riskItem.getRiskItemHasRiskCategoryList()) { - RiskItem oldRiskItemOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory = riskItemHasRiskCategoryListRiskItemHasRiskCategory.getRiskItem(); - riskItemHasRiskCategoryListRiskItemHasRiskCategory.setRiskItem(riskItem); - riskItemHasRiskCategoryListRiskItemHasRiskCategory = em.merge(riskItemHasRiskCategoryListRiskItemHasRiskCategory); - if (oldRiskItemOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory != null) { - oldRiskItemOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory.getRiskItemHasRiskCategoryList().remove(riskItemHasRiskCategoryListRiskItemHasRiskCategory); - oldRiskItemOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory = em.merge(oldRiskItemOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findRiskItem(riskItem.getRiskItemPK()) != null) { - throw new PreexistingEntityException("RiskItem " + riskItem + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(RiskItem riskItem) throws IllegalOrphanException, NonexistentEntityException, Exception { - riskItem.getRiskItemPK().setFMEAid(riskItem.getFmea().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RiskItem persistentRiskItem = em.find(RiskItem.class, riskItem.getRiskItemPK()); - Fmea fmeaOld = persistentRiskItem.getFmea(); - Fmea fmeaNew = riskItem.getFmea(); - List failureModeListOld = persistentRiskItem.getFailureModeList(); - List failureModeListNew = riskItem.getFailureModeList(); - List hazardListOld = persistentRiskItem.getHazardList(); - List hazardListNew = riskItem.getHazardList(); - List riskControlListOld = persistentRiskItem.getRiskControlList(); - List riskControlListNew = riskItem.getRiskControlList(); - List riskControlList1Old = persistentRiskItem.getRiskControlList1(); - List riskControlList1New = riskItem.getRiskControlList1(); - List causeListOld = persistentRiskItem.getCauseList(); - List causeListNew = riskItem.getCauseList(); - List riskItemHasRiskCategoryListOld = persistentRiskItem.getRiskItemHasRiskCategoryList(); - List riskItemHasRiskCategoryListNew = riskItem.getRiskItemHasRiskCategoryList(); - List illegalOrphanMessages = null; - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListOldRiskItemHasRiskCategory : riskItemHasRiskCategoryListOld) { - if (!riskItemHasRiskCategoryListNew.contains(riskItemHasRiskCategoryListOldRiskItemHasRiskCategory)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RiskItemHasRiskCategory " + riskItemHasRiskCategoryListOldRiskItemHasRiskCategory + " since its riskItem field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (fmeaNew != null) { - fmeaNew = em.getReference(fmeaNew.getClass(), fmeaNew.getId()); - riskItem.setFmea(fmeaNew); - } - List attachedFailureModeListNew = new ArrayList(); - for (FailureMode failureModeListNewFailureModeToAttach : failureModeListNew) { - failureModeListNewFailureModeToAttach = em.getReference(failureModeListNewFailureModeToAttach.getClass(), failureModeListNewFailureModeToAttach.getId()); - attachedFailureModeListNew.add(failureModeListNewFailureModeToAttach); - } - failureModeListNew = attachedFailureModeListNew; - riskItem.setFailureModeList(failureModeListNew); - List attachedHazardListNew = new ArrayList(); - for (Hazard hazardListNewHazardToAttach : hazardListNew) { - hazardListNewHazardToAttach = em.getReference(hazardListNewHazardToAttach.getClass(), hazardListNewHazardToAttach.getId()); - attachedHazardListNew.add(hazardListNewHazardToAttach); - } - hazardListNew = attachedHazardListNew; - riskItem.setHazardList(hazardListNew); - List attachedRiskControlListNew = new ArrayList(); - for (RiskControl riskControlListNewRiskControlToAttach : riskControlListNew) { - riskControlListNewRiskControlToAttach = em.getReference(riskControlListNewRiskControlToAttach.getClass(), riskControlListNewRiskControlToAttach.getRiskControlPK()); - attachedRiskControlListNew.add(riskControlListNewRiskControlToAttach); - } - riskControlListNew = attachedRiskControlListNew; - riskItem.setRiskControlList(riskControlListNew); - List attachedRiskControlList1New = new ArrayList(); - for (RiskControl riskControlList1NewRiskControlToAttach : riskControlList1New) { - riskControlList1NewRiskControlToAttach = em.getReference(riskControlList1NewRiskControlToAttach.getClass(), riskControlList1NewRiskControlToAttach.getRiskControlPK()); - attachedRiskControlList1New.add(riskControlList1NewRiskControlToAttach); - } - riskControlList1New = attachedRiskControlList1New; - riskItem.setRiskControlList1(riskControlList1New); - List attachedCauseListNew = new ArrayList(); - for (Cause causeListNewCauseToAttach : causeListNew) { - causeListNewCauseToAttach = em.getReference(causeListNewCauseToAttach.getClass(), causeListNewCauseToAttach.getId()); - attachedCauseListNew.add(causeListNewCauseToAttach); - } - causeListNew = attachedCauseListNew; - riskItem.setCauseList(causeListNew); - List attachedRiskItemHasRiskCategoryListNew = new ArrayList(); - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach : riskItemHasRiskCategoryListNew) { - riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach = em.getReference(riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach.getClass(), riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach.getRiskItemHasRiskCategoryPK()); - attachedRiskItemHasRiskCategoryListNew.add(riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach); - } - riskItemHasRiskCategoryListNew = attachedRiskItemHasRiskCategoryListNew; - riskItem.setRiskItemHasRiskCategoryList(riskItemHasRiskCategoryListNew); - riskItem = em.merge(riskItem); - if (fmeaOld != null && !fmeaOld.equals(fmeaNew)) { - fmeaOld.getRiskItemList().remove(riskItem); - fmeaOld = em.merge(fmeaOld); - } - if (fmeaNew != null && !fmeaNew.equals(fmeaOld)) { - fmeaNew.getRiskItemList().add(riskItem); - fmeaNew = em.merge(fmeaNew); - } - for (FailureMode failureModeListOldFailureMode : failureModeListOld) { - if (!failureModeListNew.contains(failureModeListOldFailureMode)) { - failureModeListOldFailureMode.getRiskItemList().remove(riskItem); - failureModeListOldFailureMode = em.merge(failureModeListOldFailureMode); - } - } - for (FailureMode failureModeListNewFailureMode : failureModeListNew) { - if (!failureModeListOld.contains(failureModeListNewFailureMode)) { - failureModeListNewFailureMode.getRiskItemList().add(riskItem); - failureModeListNewFailureMode = em.merge(failureModeListNewFailureMode); - } - } - for (Hazard hazardListOldHazard : hazardListOld) { - if (!hazardListNew.contains(hazardListOldHazard)) { - hazardListOldHazard.getRiskItemList().remove(riskItem); - hazardListOldHazard = em.merge(hazardListOldHazard); - } - } - for (Hazard hazardListNewHazard : hazardListNew) { - if (!hazardListOld.contains(hazardListNewHazard)) { - hazardListNewHazard.getRiskItemList().add(riskItem); - hazardListNewHazard = em.merge(hazardListNewHazard); - } - } - for (RiskControl riskControlListOldRiskControl : riskControlListOld) { - if (!riskControlListNew.contains(riskControlListOldRiskControl)) { - riskControlListOldRiskControl.getRiskItemList().remove(riskItem); - riskControlListOldRiskControl = em.merge(riskControlListOldRiskControl); - } - } - for (RiskControl riskControlListNewRiskControl : riskControlListNew) { - if (!riskControlListOld.contains(riskControlListNewRiskControl)) { - riskControlListNewRiskControl.getRiskItemList().add(riskItem); - riskControlListNewRiskControl = em.merge(riskControlListNewRiskControl); - } - } - for (RiskControl riskControlList1OldRiskControl : riskControlList1Old) { - if (!riskControlList1New.contains(riskControlList1OldRiskControl)) { - riskControlList1OldRiskControl.getRiskItemList1().remove(riskItem); - riskControlList1OldRiskControl = em.merge(riskControlList1OldRiskControl); - } - } - for (RiskControl riskControlList1NewRiskControl : riskControlList1New) { - if (!riskControlList1Old.contains(riskControlList1NewRiskControl)) { - riskControlList1NewRiskControl.getRiskItemList1().add(riskItem); - riskControlList1NewRiskControl = em.merge(riskControlList1NewRiskControl); - } - } - for (Cause causeListOldCause : causeListOld) { - if (!causeListNew.contains(causeListOldCause)) { - causeListOldCause.getRiskItemList().remove(riskItem); - causeListOldCause = em.merge(causeListOldCause); - } - } - for (Cause causeListNewCause : causeListNew) { - if (!causeListOld.contains(causeListNewCause)) { - causeListNewCause.getRiskItemList().add(riskItem); - causeListNewCause = em.merge(causeListNewCause); - } - } - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListNewRiskItemHasRiskCategory : riskItemHasRiskCategoryListNew) { - if (!riskItemHasRiskCategoryListOld.contains(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory)) { - RiskItem oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory = riskItemHasRiskCategoryListNewRiskItemHasRiskCategory.getRiskItem(); - riskItemHasRiskCategoryListNewRiskItemHasRiskCategory.setRiskItem(riskItem); - riskItemHasRiskCategoryListNewRiskItemHasRiskCategory = em.merge(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory); - if (oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory != null && !oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory.equals(riskItem)) { - oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory.getRiskItemHasRiskCategoryList().remove(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory); - oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory = em.merge(oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - RiskItemPK id = riskItem.getRiskItemPK(); - if (findRiskItem(id) == null) { - throw new NonexistentEntityException("The riskItem with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(RiskItemPK id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RiskItem riskItem; - try { - riskItem = em.getReference(RiskItem.class, id); - riskItem.getRiskItemPK(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The riskItem with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List riskItemHasRiskCategoryListOrphanCheck = riskItem.getRiskItemHasRiskCategoryList(); - for (RiskItemHasRiskCategory riskItemHasRiskCategoryListOrphanCheckRiskItemHasRiskCategory : riskItemHasRiskCategoryListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RiskItem (" + riskItem + ") cannot be destroyed since the RiskItemHasRiskCategory " + riskItemHasRiskCategoryListOrphanCheckRiskItemHasRiskCategory + " in its riskItemHasRiskCategoryList field has a non-nullable riskItem field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - Fmea fmea = riskItem.getFmea(); - if (fmea != null) { - fmea.getRiskItemList().remove(riskItem); - fmea = em.merge(fmea); - } - List failureModeList = riskItem.getFailureModeList(); - for (FailureMode failureModeListFailureMode : failureModeList) { - failureModeListFailureMode.getRiskItemList().remove(riskItem); - failureModeListFailureMode = em.merge(failureModeListFailureMode); - } - List hazardList = riskItem.getHazardList(); - for (Hazard hazardListHazard : hazardList) { - hazardListHazard.getRiskItemList().remove(riskItem); - hazardListHazard = em.merge(hazardListHazard); - } - List riskControlList = riskItem.getRiskControlList(); - for (RiskControl riskControlListRiskControl : riskControlList) { - riskControlListRiskControl.getRiskItemList().remove(riskItem); - riskControlListRiskControl = em.merge(riskControlListRiskControl); - } - List riskControlList1 = riskItem.getRiskControlList1(); - for (RiskControl riskControlList1RiskControl : riskControlList1) { - riskControlList1RiskControl.getRiskItemList1().remove(riskItem); - riskControlList1RiskControl = em.merge(riskControlList1RiskControl); - } - List causeList = riskItem.getCauseList(); - for (Cause causeListCause : causeList) { - causeListCause.getRiskItemList().remove(riskItem); - causeListCause = em.merge(causeListCause); - } - em.remove(riskItem); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRiskItemEntities() { - return findRiskItemEntities(true, -1, -1); - } - - public List findRiskItemEntities(int maxResults, int firstResult) { - return findRiskItemEntities(false, maxResults, firstResult); - } - - private List findRiskItemEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(RiskItem.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public RiskItem findRiskItem(RiskItemPK id) { - EntityManager em = getEntityManager(); - try { - return em.find(RiskItem.class, id); - } - finally { - em.close(); - } - } - - public int getRiskItemCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(RiskItem.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Fmea; +import com.validation.manager.core.db.FailureMode; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.Hazard; +import com.validation.manager.core.db.RiskControl; +import com.validation.manager.core.db.Cause; +import com.validation.manager.core.db.RiskItem; +import com.validation.manager.core.db.RiskItemHasRiskCategory; +import com.validation.manager.core.db.RiskItemPK; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RiskItemJpaController implements Serializable { + + public RiskItemJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(RiskItem riskItem) throws PreexistingEntityException, Exception { + if (riskItem.getRiskItemPK() == null) { + riskItem.setRiskItemPK(new RiskItemPK()); + } + if (riskItem.getFailureModeList() == null) { + riskItem.setFailureModeList(new ArrayList<>()); + } + if (riskItem.getHazardList() == null) { + riskItem.setHazardList(new ArrayList<>()); + } + if (riskItem.getRiskControlList() == null) { + riskItem.setRiskControlList(new ArrayList<>()); + } + if (riskItem.getRiskControlList1() == null) { + riskItem.setRiskControlList1(new ArrayList<>()); + } + if (riskItem.getCauseList() == null) { + riskItem.setCauseList(new ArrayList<>()); + } + if (riskItem.getRiskItemHasRiskCategoryList() == null) { + riskItem.setRiskItemHasRiskCategoryList(new ArrayList<>()); + } + riskItem.getRiskItemPK().setFMEAid(riskItem.getFmea().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Fmea fmea = riskItem.getFmea(); + if (fmea != null) { + fmea = em.getReference(fmea.getClass(), fmea.getId()); + riskItem.setFmea(fmea); + } + List attachedFailureModeList = new ArrayList<>(); + for (FailureMode failureModeListFailureModeToAttach : riskItem.getFailureModeList()) { + failureModeListFailureModeToAttach = em.getReference(failureModeListFailureModeToAttach.getClass(), failureModeListFailureModeToAttach.getId()); + attachedFailureModeList.add(failureModeListFailureModeToAttach); + } + riskItem.setFailureModeList(attachedFailureModeList); + List attachedHazardList = new ArrayList<>(); + for (Hazard hazardListHazardToAttach : riskItem.getHazardList()) { + hazardListHazardToAttach = em.getReference(hazardListHazardToAttach.getClass(), hazardListHazardToAttach.getId()); + attachedHazardList.add(hazardListHazardToAttach); + } + riskItem.setHazardList(attachedHazardList); + List attachedRiskControlList = new ArrayList<>(); + for (RiskControl riskControlListRiskControlToAttach : riskItem.getRiskControlList()) { + riskControlListRiskControlToAttach = em.getReference(riskControlListRiskControlToAttach.getClass(), riskControlListRiskControlToAttach.getRiskControlPK()); + attachedRiskControlList.add(riskControlListRiskControlToAttach); + } + riskItem.setRiskControlList(attachedRiskControlList); + List attachedRiskControlList1 = new ArrayList<>(); + for (RiskControl riskControlList1RiskControlToAttach : riskItem.getRiskControlList1()) { + riskControlList1RiskControlToAttach = em.getReference(riskControlList1RiskControlToAttach.getClass(), riskControlList1RiskControlToAttach.getRiskControlPK()); + attachedRiskControlList1.add(riskControlList1RiskControlToAttach); + } + riskItem.setRiskControlList1(attachedRiskControlList1); + List attachedCauseList = new ArrayList<>(); + for (Cause causeListCauseToAttach : riskItem.getCauseList()) { + causeListCauseToAttach = em.getReference(causeListCauseToAttach.getClass(), causeListCauseToAttach.getId()); + attachedCauseList.add(causeListCauseToAttach); + } + riskItem.setCauseList(attachedCauseList); + List attachedRiskItemHasRiskCategoryList = new ArrayList<>(); + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach : riskItem.getRiskItemHasRiskCategoryList()) { + riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach = em.getReference(riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach.getClass(), riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach.getRiskItemHasRiskCategoryPK()); + attachedRiskItemHasRiskCategoryList.add(riskItemHasRiskCategoryListRiskItemHasRiskCategoryToAttach); + } + riskItem.setRiskItemHasRiskCategoryList(attachedRiskItemHasRiskCategoryList); + em.persist(riskItem); + if (fmea != null) { + fmea.getRiskItemList().add(riskItem); + fmea = em.merge(fmea); + } + for (FailureMode failureModeListFailureMode : riskItem.getFailureModeList()) { + failureModeListFailureMode.getRiskItemList().add(riskItem); + failureModeListFailureMode = em.merge(failureModeListFailureMode); + } + for (Hazard hazardListHazard : riskItem.getHazardList()) { + hazardListHazard.getRiskItemList().add(riskItem); + hazardListHazard = em.merge(hazardListHazard); + } + for (RiskControl riskControlListRiskControl : riskItem.getRiskControlList()) { + riskControlListRiskControl.getRiskItemList().add(riskItem); + riskControlListRiskControl = em.merge(riskControlListRiskControl); + } + for (RiskControl riskControlList1RiskControl : riskItem.getRiskControlList1()) { + riskControlList1RiskControl.getRiskItemList1().add(riskItem); + riskControlList1RiskControl = em.merge(riskControlList1RiskControl); + } + for (Cause causeListCause : riskItem.getCauseList()) { + causeListCause.getRiskItemList().add(riskItem); + causeListCause = em.merge(causeListCause); + } + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListRiskItemHasRiskCategory : riskItem.getRiskItemHasRiskCategoryList()) { + RiskItem oldRiskItemOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory = riskItemHasRiskCategoryListRiskItemHasRiskCategory.getRiskItem(); + riskItemHasRiskCategoryListRiskItemHasRiskCategory.setRiskItem(riskItem); + riskItemHasRiskCategoryListRiskItemHasRiskCategory = em.merge(riskItemHasRiskCategoryListRiskItemHasRiskCategory); + if (oldRiskItemOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory != null) { + oldRiskItemOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory.getRiskItemHasRiskCategoryList().remove(riskItemHasRiskCategoryListRiskItemHasRiskCategory); + oldRiskItemOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory = em.merge(oldRiskItemOfRiskItemHasRiskCategoryListRiskItemHasRiskCategory); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findRiskItem(riskItem.getRiskItemPK()) != null) { + throw new PreexistingEntityException("RiskItem " + riskItem + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(RiskItem riskItem) throws IllegalOrphanException, NonexistentEntityException, Exception { + riskItem.getRiskItemPK().setFMEAid(riskItem.getFmea().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RiskItem persistentRiskItem = em.find(RiskItem.class, riskItem.getRiskItemPK()); + Fmea fmeaOld = persistentRiskItem.getFmea(); + Fmea fmeaNew = riskItem.getFmea(); + List failureModeListOld = persistentRiskItem.getFailureModeList(); + List failureModeListNew = riskItem.getFailureModeList(); + List hazardListOld = persistentRiskItem.getHazardList(); + List hazardListNew = riskItem.getHazardList(); + List riskControlListOld = persistentRiskItem.getRiskControlList(); + List riskControlListNew = riskItem.getRiskControlList(); + List riskControlList1Old = persistentRiskItem.getRiskControlList1(); + List riskControlList1New = riskItem.getRiskControlList1(); + List causeListOld = persistentRiskItem.getCauseList(); + List causeListNew = riskItem.getCauseList(); + List riskItemHasRiskCategoryListOld = persistentRiskItem.getRiskItemHasRiskCategoryList(); + List riskItemHasRiskCategoryListNew = riskItem.getRiskItemHasRiskCategoryList(); + List illegalOrphanMessages = null; + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListOldRiskItemHasRiskCategory : riskItemHasRiskCategoryListOld) { + if (!riskItemHasRiskCategoryListNew.contains(riskItemHasRiskCategoryListOldRiskItemHasRiskCategory)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RiskItemHasRiskCategory " + riskItemHasRiskCategoryListOldRiskItemHasRiskCategory + " since its riskItem field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (fmeaNew != null) { + fmeaNew = em.getReference(fmeaNew.getClass(), fmeaNew.getId()); + riskItem.setFmea(fmeaNew); + } + List attachedFailureModeListNew = new ArrayList<>(); + for (FailureMode failureModeListNewFailureModeToAttach : failureModeListNew) { + failureModeListNewFailureModeToAttach = em.getReference(failureModeListNewFailureModeToAttach.getClass(), failureModeListNewFailureModeToAttach.getId()); + attachedFailureModeListNew.add(failureModeListNewFailureModeToAttach); + } + failureModeListNew = attachedFailureModeListNew; + riskItem.setFailureModeList(failureModeListNew); + List attachedHazardListNew = new ArrayList<>(); + for (Hazard hazardListNewHazardToAttach : hazardListNew) { + hazardListNewHazardToAttach = em.getReference(hazardListNewHazardToAttach.getClass(), hazardListNewHazardToAttach.getId()); + attachedHazardListNew.add(hazardListNewHazardToAttach); + } + hazardListNew = attachedHazardListNew; + riskItem.setHazardList(hazardListNew); + List attachedRiskControlListNew = new ArrayList<>(); + for (RiskControl riskControlListNewRiskControlToAttach : riskControlListNew) { + riskControlListNewRiskControlToAttach = em.getReference(riskControlListNewRiskControlToAttach.getClass(), riskControlListNewRiskControlToAttach.getRiskControlPK()); + attachedRiskControlListNew.add(riskControlListNewRiskControlToAttach); + } + riskControlListNew = attachedRiskControlListNew; + riskItem.setRiskControlList(riskControlListNew); + List attachedRiskControlList1New = new ArrayList<>(); + for (RiskControl riskControlList1NewRiskControlToAttach : riskControlList1New) { + riskControlList1NewRiskControlToAttach = em.getReference(riskControlList1NewRiskControlToAttach.getClass(), riskControlList1NewRiskControlToAttach.getRiskControlPK()); + attachedRiskControlList1New.add(riskControlList1NewRiskControlToAttach); + } + riskControlList1New = attachedRiskControlList1New; + riskItem.setRiskControlList1(riskControlList1New); + List attachedCauseListNew = new ArrayList<>(); + for (Cause causeListNewCauseToAttach : causeListNew) { + causeListNewCauseToAttach = em.getReference(causeListNewCauseToAttach.getClass(), causeListNewCauseToAttach.getId()); + attachedCauseListNew.add(causeListNewCauseToAttach); + } + causeListNew = attachedCauseListNew; + riskItem.setCauseList(causeListNew); + List attachedRiskItemHasRiskCategoryListNew = new ArrayList<>(); + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach : riskItemHasRiskCategoryListNew) { + riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach = em.getReference(riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach.getClass(), riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach.getRiskItemHasRiskCategoryPK()); + attachedRiskItemHasRiskCategoryListNew.add(riskItemHasRiskCategoryListNewRiskItemHasRiskCategoryToAttach); + } + riskItemHasRiskCategoryListNew = attachedRiskItemHasRiskCategoryListNew; + riskItem.setRiskItemHasRiskCategoryList(riskItemHasRiskCategoryListNew); + riskItem = em.merge(riskItem); + if (fmeaOld != null && !fmeaOld.equals(fmeaNew)) { + fmeaOld.getRiskItemList().remove(riskItem); + fmeaOld = em.merge(fmeaOld); + } + if (fmeaNew != null && !fmeaNew.equals(fmeaOld)) { + fmeaNew.getRiskItemList().add(riskItem); + fmeaNew = em.merge(fmeaNew); + } + for (FailureMode failureModeListOldFailureMode : failureModeListOld) { + if (!failureModeListNew.contains(failureModeListOldFailureMode)) { + failureModeListOldFailureMode.getRiskItemList().remove(riskItem); + failureModeListOldFailureMode = em.merge(failureModeListOldFailureMode); + } + } + for (FailureMode failureModeListNewFailureMode : failureModeListNew) { + if (!failureModeListOld.contains(failureModeListNewFailureMode)) { + failureModeListNewFailureMode.getRiskItemList().add(riskItem); + failureModeListNewFailureMode = em.merge(failureModeListNewFailureMode); + } + } + for (Hazard hazardListOldHazard : hazardListOld) { + if (!hazardListNew.contains(hazardListOldHazard)) { + hazardListOldHazard.getRiskItemList().remove(riskItem); + hazardListOldHazard = em.merge(hazardListOldHazard); + } + } + for (Hazard hazardListNewHazard : hazardListNew) { + if (!hazardListOld.contains(hazardListNewHazard)) { + hazardListNewHazard.getRiskItemList().add(riskItem); + hazardListNewHazard = em.merge(hazardListNewHazard); + } + } + for (RiskControl riskControlListOldRiskControl : riskControlListOld) { + if (!riskControlListNew.contains(riskControlListOldRiskControl)) { + riskControlListOldRiskControl.getRiskItemList().remove(riskItem); + riskControlListOldRiskControl = em.merge(riskControlListOldRiskControl); + } + } + for (RiskControl riskControlListNewRiskControl : riskControlListNew) { + if (!riskControlListOld.contains(riskControlListNewRiskControl)) { + riskControlListNewRiskControl.getRiskItemList().add(riskItem); + riskControlListNewRiskControl = em.merge(riskControlListNewRiskControl); + } + } + for (RiskControl riskControlList1OldRiskControl : riskControlList1Old) { + if (!riskControlList1New.contains(riskControlList1OldRiskControl)) { + riskControlList1OldRiskControl.getRiskItemList1().remove(riskItem); + riskControlList1OldRiskControl = em.merge(riskControlList1OldRiskControl); + } + } + for (RiskControl riskControlList1NewRiskControl : riskControlList1New) { + if (!riskControlList1Old.contains(riskControlList1NewRiskControl)) { + riskControlList1NewRiskControl.getRiskItemList1().add(riskItem); + riskControlList1NewRiskControl = em.merge(riskControlList1NewRiskControl); + } + } + for (Cause causeListOldCause : causeListOld) { + if (!causeListNew.contains(causeListOldCause)) { + causeListOldCause.getRiskItemList().remove(riskItem); + causeListOldCause = em.merge(causeListOldCause); + } + } + for (Cause causeListNewCause : causeListNew) { + if (!causeListOld.contains(causeListNewCause)) { + causeListNewCause.getRiskItemList().add(riskItem); + causeListNewCause = em.merge(causeListNewCause); + } + } + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListNewRiskItemHasRiskCategory : riskItemHasRiskCategoryListNew) { + if (!riskItemHasRiskCategoryListOld.contains(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory)) { + RiskItem oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory = riskItemHasRiskCategoryListNewRiskItemHasRiskCategory.getRiskItem(); + riskItemHasRiskCategoryListNewRiskItemHasRiskCategory.setRiskItem(riskItem); + riskItemHasRiskCategoryListNewRiskItemHasRiskCategory = em.merge(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory); + if (oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory != null && !oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory.equals(riskItem)) { + oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory.getRiskItemHasRiskCategoryList().remove(riskItemHasRiskCategoryListNewRiskItemHasRiskCategory); + oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory = em.merge(oldRiskItemOfRiskItemHasRiskCategoryListNewRiskItemHasRiskCategory); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + RiskItemPK id = riskItem.getRiskItemPK(); + if (findRiskItem(id) == null) { + throw new NonexistentEntityException("The riskItem with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(RiskItemPK id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RiskItem riskItem; + try { + riskItem = em.getReference(RiskItem.class, id); + riskItem.getRiskItemPK(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The riskItem with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List riskItemHasRiskCategoryListOrphanCheck = riskItem.getRiskItemHasRiskCategoryList(); + for (RiskItemHasRiskCategory riskItemHasRiskCategoryListOrphanCheckRiskItemHasRiskCategory : riskItemHasRiskCategoryListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RiskItem (" + riskItem + ") cannot be destroyed since the RiskItemHasRiskCategory " + riskItemHasRiskCategoryListOrphanCheckRiskItemHasRiskCategory + " in its riskItemHasRiskCategoryList field has a non-nullable riskItem field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + Fmea fmea = riskItem.getFmea(); + if (fmea != null) { + fmea.getRiskItemList().remove(riskItem); + fmea = em.merge(fmea); + } + List failureModeList = riskItem.getFailureModeList(); + for (FailureMode failureModeListFailureMode : failureModeList) { + failureModeListFailureMode.getRiskItemList().remove(riskItem); + failureModeListFailureMode = em.merge(failureModeListFailureMode); + } + List hazardList = riskItem.getHazardList(); + for (Hazard hazardListHazard : hazardList) { + hazardListHazard.getRiskItemList().remove(riskItem); + hazardListHazard = em.merge(hazardListHazard); + } + List riskControlList = riskItem.getRiskControlList(); + for (RiskControl riskControlListRiskControl : riskControlList) { + riskControlListRiskControl.getRiskItemList().remove(riskItem); + riskControlListRiskControl = em.merge(riskControlListRiskControl); + } + List riskControlList1 = riskItem.getRiskControlList1(); + for (RiskControl riskControlList1RiskControl : riskControlList1) { + riskControlList1RiskControl.getRiskItemList1().remove(riskItem); + riskControlList1RiskControl = em.merge(riskControlList1RiskControl); + } + List causeList = riskItem.getCauseList(); + for (Cause causeListCause : causeList) { + causeListCause.getRiskItemList().remove(riskItem); + causeListCause = em.merge(causeListCause); + } + em.remove(riskItem); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRiskItemEntities() { + return findRiskItemEntities(true, -1, -1); + } + + public List findRiskItemEntities(int maxResults, int firstResult) { + return findRiskItemEntities(false, maxResults, firstResult); + } + + private List findRiskItemEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(RiskItem.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public RiskItem findRiskItem(RiskItemPK id) { + EntityManager em = getEntityManager(); + try { + return em.find(RiskItem.class, id); + } + finally { + em.close(); + } + } + + public int getRiskItemCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(RiskItem.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RoleJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RoleJpaController.java index 28bb8041..98469f13 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RoleJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RoleJpaController.java @@ -13,397 +13,397 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.VmUser; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.UserRight; -import com.validation.manager.core.db.UserTestProjectRole; -import com.validation.manager.core.db.UserTestPlanRole; -import com.validation.manager.core.db.ExecutionStepHasVmUser; -import com.validation.manager.core.db.Role; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RoleJpaController implements Serializable { - - public RoleJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(Role role) { - if (role.getVmUserList() == null) { - role.setVmUserList(new ArrayList()); - } - if (role.getUserRightList() == null) { - role.setUserRightList(new ArrayList()); - } - if (role.getUserTestProjectRoleList() == null) { - role.setUserTestProjectRoleList(new ArrayList()); - } - if (role.getUserTestPlanRoleList() == null) { - role.setUserTestPlanRoleList(new ArrayList()); - } - if (role.getExecutionStepHasVmUserList() == null) { - role.setExecutionStepHasVmUserList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedVmUserList = new ArrayList(); - for (VmUser vmUserListVmUserToAttach : role.getVmUserList()) { - vmUserListVmUserToAttach = em.getReference(vmUserListVmUserToAttach.getClass(), vmUserListVmUserToAttach.getId()); - attachedVmUserList.add(vmUserListVmUserToAttach); - } - role.setVmUserList(attachedVmUserList); - List attachedUserRightList = new ArrayList(); - for (UserRight userRightListUserRightToAttach : role.getUserRightList()) { - userRightListUserRightToAttach = em.getReference(userRightListUserRightToAttach.getClass(), userRightListUserRightToAttach.getId()); - attachedUserRightList.add(userRightListUserRightToAttach); - } - role.setUserRightList(attachedUserRightList); - List attachedUserTestProjectRoleList = new ArrayList(); - for (UserTestProjectRole userTestProjectRoleListUserTestProjectRoleToAttach : role.getUserTestProjectRoleList()) { - userTestProjectRoleListUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListUserTestProjectRoleToAttach.getUserTestProjectRolePK()); - attachedUserTestProjectRoleList.add(userTestProjectRoleListUserTestProjectRoleToAttach); - } - role.setUserTestProjectRoleList(attachedUserTestProjectRoleList); - List attachedUserTestPlanRoleList = new ArrayList(); - for (UserTestPlanRole userTestPlanRoleListUserTestPlanRoleToAttach : role.getUserTestPlanRoleList()) { - userTestPlanRoleListUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListUserTestPlanRoleToAttach.getUserTestPlanRolePK()); - attachedUserTestPlanRoleList.add(userTestPlanRoleListUserTestPlanRoleToAttach); - } - role.setUserTestPlanRoleList(attachedUserTestPlanRoleList); - List attachedExecutionStepHasVmUserList = new ArrayList(); - for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUserToAttach : role.getExecutionStepHasVmUserList()) { - executionStepHasVmUserListExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); - attachedExecutionStepHasVmUserList.add(executionStepHasVmUserListExecutionStepHasVmUserToAttach); - } - role.setExecutionStepHasVmUserList(attachedExecutionStepHasVmUserList); - em.persist(role); - for (VmUser vmUserListVmUser : role.getVmUserList()) { - vmUserListVmUser.getRoleList().add(role); - vmUserListVmUser = em.merge(vmUserListVmUser); - } - for (UserRight userRightListUserRight : role.getUserRightList()) { - userRightListUserRight.getRoleList().add(role); - userRightListUserRight = em.merge(userRightListUserRight); - } - for (UserTestProjectRole userTestProjectRoleListUserTestProjectRole : role.getUserTestProjectRoleList()) { - Role oldRoleOfUserTestProjectRoleListUserTestProjectRole = userTestProjectRoleListUserTestProjectRole.getRole(); - userTestProjectRoleListUserTestProjectRole.setRole(role); - userTestProjectRoleListUserTestProjectRole = em.merge(userTestProjectRoleListUserTestProjectRole); - if (oldRoleOfUserTestProjectRoleListUserTestProjectRole != null) { - oldRoleOfUserTestProjectRoleListUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListUserTestProjectRole); - oldRoleOfUserTestProjectRoleListUserTestProjectRole = em.merge(oldRoleOfUserTestProjectRoleListUserTestProjectRole); - } - } - for (UserTestPlanRole userTestPlanRoleListUserTestPlanRole : role.getUserTestPlanRoleList()) { - Role oldRoleOfUserTestPlanRoleListUserTestPlanRole = userTestPlanRoleListUserTestPlanRole.getRole(); - userTestPlanRoleListUserTestPlanRole.setRole(role); - userTestPlanRoleListUserTestPlanRole = em.merge(userTestPlanRoleListUserTestPlanRole); - if (oldRoleOfUserTestPlanRoleListUserTestPlanRole != null) { - oldRoleOfUserTestPlanRoleListUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListUserTestPlanRole); - oldRoleOfUserTestPlanRoleListUserTestPlanRole = em.merge(oldRoleOfUserTestPlanRoleListUserTestPlanRole); - } - } - for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUser : role.getExecutionStepHasVmUserList()) { - Role oldRoleOfExecutionStepHasVmUserListExecutionStepHasVmUser = executionStepHasVmUserListExecutionStepHasVmUser.getRole(); - executionStepHasVmUserListExecutionStepHasVmUser.setRole(role); - executionStepHasVmUserListExecutionStepHasVmUser = em.merge(executionStepHasVmUserListExecutionStepHasVmUser); - if (oldRoleOfExecutionStepHasVmUserListExecutionStepHasVmUser != null) { - oldRoleOfExecutionStepHasVmUserListExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListExecutionStepHasVmUser); - oldRoleOfExecutionStepHasVmUserListExecutionStepHasVmUser = em.merge(oldRoleOfExecutionStepHasVmUserListExecutionStepHasVmUser); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(Role role) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Role persistentRole = em.find(Role.class, role.getId()); - List vmUserListOld = persistentRole.getVmUserList(); - List vmUserListNew = role.getVmUserList(); - List userRightListOld = persistentRole.getUserRightList(); - List userRightListNew = role.getUserRightList(); - List userTestProjectRoleListOld = persistentRole.getUserTestProjectRoleList(); - List userTestProjectRoleListNew = role.getUserTestProjectRoleList(); - List userTestPlanRoleListOld = persistentRole.getUserTestPlanRoleList(); - List userTestPlanRoleListNew = role.getUserTestPlanRoleList(); - List executionStepHasVmUserListOld = persistentRole.getExecutionStepHasVmUserList(); - List executionStepHasVmUserListNew = role.getExecutionStepHasVmUserList(); - List illegalOrphanMessages = null; - for (UserTestProjectRole userTestProjectRoleListOldUserTestProjectRole : userTestProjectRoleListOld) { - if (!userTestProjectRoleListNew.contains(userTestProjectRoleListOldUserTestProjectRole)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserTestProjectRole " + userTestProjectRoleListOldUserTestProjectRole + " since its role field is not nullable."); - } - } - for (UserTestPlanRole userTestPlanRoleListOldUserTestPlanRole : userTestPlanRoleListOld) { - if (!userTestPlanRoleListNew.contains(userTestPlanRoleListOldUserTestPlanRole)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserTestPlanRole " + userTestPlanRoleListOldUserTestPlanRole + " since its role field is not nullable."); - } - } - for (ExecutionStepHasVmUser executionStepHasVmUserListOldExecutionStepHasVmUser : executionStepHasVmUserListOld) { - if (!executionStepHasVmUserListNew.contains(executionStepHasVmUserListOldExecutionStepHasVmUser)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExecutionStepHasVmUser " + executionStepHasVmUserListOldExecutionStepHasVmUser + " since its role field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedVmUserListNew = new ArrayList(); - for (VmUser vmUserListNewVmUserToAttach : vmUserListNew) { - vmUserListNewVmUserToAttach = em.getReference(vmUserListNewVmUserToAttach.getClass(), vmUserListNewVmUserToAttach.getId()); - attachedVmUserListNew.add(vmUserListNewVmUserToAttach); - } - vmUserListNew = attachedVmUserListNew; - role.setVmUserList(vmUserListNew); - List attachedUserRightListNew = new ArrayList(); - for (UserRight userRightListNewUserRightToAttach : userRightListNew) { - userRightListNewUserRightToAttach = em.getReference(userRightListNewUserRightToAttach.getClass(), userRightListNewUserRightToAttach.getId()); - attachedUserRightListNew.add(userRightListNewUserRightToAttach); - } - userRightListNew = attachedUserRightListNew; - role.setUserRightList(userRightListNew); - List attachedUserTestProjectRoleListNew = new ArrayList(); - for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRoleToAttach : userTestProjectRoleListNew) { - userTestProjectRoleListNewUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListNewUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListNewUserTestProjectRoleToAttach.getUserTestProjectRolePK()); - attachedUserTestProjectRoleListNew.add(userTestProjectRoleListNewUserTestProjectRoleToAttach); - } - userTestProjectRoleListNew = attachedUserTestProjectRoleListNew; - role.setUserTestProjectRoleList(userTestProjectRoleListNew); - List attachedUserTestPlanRoleListNew = new ArrayList(); - for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRoleToAttach : userTestPlanRoleListNew) { - userTestPlanRoleListNewUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListNewUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListNewUserTestPlanRoleToAttach.getUserTestPlanRolePK()); - attachedUserTestPlanRoleListNew.add(userTestPlanRoleListNewUserTestPlanRoleToAttach); - } - userTestPlanRoleListNew = attachedUserTestPlanRoleListNew; - role.setUserTestPlanRoleList(userTestPlanRoleListNew); - List attachedExecutionStepHasVmUserListNew = new ArrayList(); - for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUserToAttach : executionStepHasVmUserListNew) { - executionStepHasVmUserListNewExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); - attachedExecutionStepHasVmUserListNew.add(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach); - } - executionStepHasVmUserListNew = attachedExecutionStepHasVmUserListNew; - role.setExecutionStepHasVmUserList(executionStepHasVmUserListNew); - role = em.merge(role); - for (VmUser vmUserListOldVmUser : vmUserListOld) { - if (!vmUserListNew.contains(vmUserListOldVmUser)) { - vmUserListOldVmUser.getRoleList().remove(role); - vmUserListOldVmUser = em.merge(vmUserListOldVmUser); - } - } - for (VmUser vmUserListNewVmUser : vmUserListNew) { - if (!vmUserListOld.contains(vmUserListNewVmUser)) { - vmUserListNewVmUser.getRoleList().add(role); - vmUserListNewVmUser = em.merge(vmUserListNewVmUser); - } - } - for (UserRight userRightListOldUserRight : userRightListOld) { - if (!userRightListNew.contains(userRightListOldUserRight)) { - userRightListOldUserRight.getRoleList().remove(role); - userRightListOldUserRight = em.merge(userRightListOldUserRight); - } - } - for (UserRight userRightListNewUserRight : userRightListNew) { - if (!userRightListOld.contains(userRightListNewUserRight)) { - userRightListNewUserRight.getRoleList().add(role); - userRightListNewUserRight = em.merge(userRightListNewUserRight); - } - } - for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRole : userTestProjectRoleListNew) { - if (!userTestProjectRoleListOld.contains(userTestProjectRoleListNewUserTestProjectRole)) { - Role oldRoleOfUserTestProjectRoleListNewUserTestProjectRole = userTestProjectRoleListNewUserTestProjectRole.getRole(); - userTestProjectRoleListNewUserTestProjectRole.setRole(role); - userTestProjectRoleListNewUserTestProjectRole = em.merge(userTestProjectRoleListNewUserTestProjectRole); - if (oldRoleOfUserTestProjectRoleListNewUserTestProjectRole != null && !oldRoleOfUserTestProjectRoleListNewUserTestProjectRole.equals(role)) { - oldRoleOfUserTestProjectRoleListNewUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListNewUserTestProjectRole); - oldRoleOfUserTestProjectRoleListNewUserTestProjectRole = em.merge(oldRoleOfUserTestProjectRoleListNewUserTestProjectRole); - } - } - } - for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRole : userTestPlanRoleListNew) { - if (!userTestPlanRoleListOld.contains(userTestPlanRoleListNewUserTestPlanRole)) { - Role oldRoleOfUserTestPlanRoleListNewUserTestPlanRole = userTestPlanRoleListNewUserTestPlanRole.getRole(); - userTestPlanRoleListNewUserTestPlanRole.setRole(role); - userTestPlanRoleListNewUserTestPlanRole = em.merge(userTestPlanRoleListNewUserTestPlanRole); - if (oldRoleOfUserTestPlanRoleListNewUserTestPlanRole != null && !oldRoleOfUserTestPlanRoleListNewUserTestPlanRole.equals(role)) { - oldRoleOfUserTestPlanRoleListNewUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListNewUserTestPlanRole); - oldRoleOfUserTestPlanRoleListNewUserTestPlanRole = em.merge(oldRoleOfUserTestPlanRoleListNewUserTestPlanRole); - } - } - } - for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUser : executionStepHasVmUserListNew) { - if (!executionStepHasVmUserListOld.contains(executionStepHasVmUserListNewExecutionStepHasVmUser)) { - Role oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = executionStepHasVmUserListNewExecutionStepHasVmUser.getRole(); - executionStepHasVmUserListNewExecutionStepHasVmUser.setRole(role); - executionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(executionStepHasVmUserListNewExecutionStepHasVmUser); - if (oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser != null && !oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.equals(role)) { - oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListNewExecutionStepHasVmUser); - oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = role.getId(); - if (findRole(id) == null) { - throw new NonexistentEntityException("The role with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Role role; - try { - role = em.getReference(Role.class, id); - role.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The role with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List userTestProjectRoleListOrphanCheck = role.getUserTestProjectRoleList(); - for (UserTestProjectRole userTestProjectRoleListOrphanCheckUserTestProjectRole : userTestProjectRoleListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Role (" + role + ") cannot be destroyed since the UserTestProjectRole " + userTestProjectRoleListOrphanCheckUserTestProjectRole + " in its userTestProjectRoleList field has a non-nullable role field."); - } - List userTestPlanRoleListOrphanCheck = role.getUserTestPlanRoleList(); - for (UserTestPlanRole userTestPlanRoleListOrphanCheckUserTestPlanRole : userTestPlanRoleListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Role (" + role + ") cannot be destroyed since the UserTestPlanRole " + userTestPlanRoleListOrphanCheckUserTestPlanRole + " in its userTestPlanRoleList field has a non-nullable role field."); - } - List executionStepHasVmUserListOrphanCheck = role.getExecutionStepHasVmUserList(); - for (ExecutionStepHasVmUser executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser : executionStepHasVmUserListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Role (" + role + ") cannot be destroyed since the ExecutionStepHasVmUser " + executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser + " in its executionStepHasVmUserList field has a non-nullable role field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List vmUserList = role.getVmUserList(); - for (VmUser vmUserListVmUser : vmUserList) { - vmUserListVmUser.getRoleList().remove(role); - vmUserListVmUser = em.merge(vmUserListVmUser); - } - List userRightList = role.getUserRightList(); - for (UserRight userRightListUserRight : userRightList) { - userRightListUserRight.getRoleList().remove(role); - userRightListUserRight = em.merge(userRightListUserRight); - } - em.remove(role); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRoleEntities() { - return findRoleEntities(true, -1, -1); - } - - public List findRoleEntities(int maxResults, int firstResult) { - return findRoleEntities(false, maxResults, firstResult); - } - - private List findRoleEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(Role.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public Role findRole(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(Role.class, id); - } - finally { - em.close(); - } - } - - public int getRoleCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(Role.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.VmUser; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.UserRight; +import com.validation.manager.core.db.UserTestProjectRole; +import com.validation.manager.core.db.UserTestPlanRole; +import com.validation.manager.core.db.ExecutionStepHasVmUser; +import com.validation.manager.core.db.Role; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RoleJpaController implements Serializable { + + public RoleJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(Role role) { + if (role.getVmUserList() == null) { + role.setVmUserList(new ArrayList<>()); + } + if (role.getUserRightList() == null) { + role.setUserRightList(new ArrayList<>()); + } + if (role.getUserTestProjectRoleList() == null) { + role.setUserTestProjectRoleList(new ArrayList<>()); + } + if (role.getUserTestPlanRoleList() == null) { + role.setUserTestPlanRoleList(new ArrayList<>()); + } + if (role.getExecutionStepHasVmUserList() == null) { + role.setExecutionStepHasVmUserList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedVmUserList = new ArrayList<>(); + for (VmUser vmUserListVmUserToAttach : role.getVmUserList()) { + vmUserListVmUserToAttach = em.getReference(vmUserListVmUserToAttach.getClass(), vmUserListVmUserToAttach.getId()); + attachedVmUserList.add(vmUserListVmUserToAttach); + } + role.setVmUserList(attachedVmUserList); + List attachedUserRightList = new ArrayList<>(); + for (UserRight userRightListUserRightToAttach : role.getUserRightList()) { + userRightListUserRightToAttach = em.getReference(userRightListUserRightToAttach.getClass(), userRightListUserRightToAttach.getId()); + attachedUserRightList.add(userRightListUserRightToAttach); + } + role.setUserRightList(attachedUserRightList); + List attachedUserTestProjectRoleList = new ArrayList<>(); + for (UserTestProjectRole userTestProjectRoleListUserTestProjectRoleToAttach : role.getUserTestProjectRoleList()) { + userTestProjectRoleListUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListUserTestProjectRoleToAttach.getUserTestProjectRolePK()); + attachedUserTestProjectRoleList.add(userTestProjectRoleListUserTestProjectRoleToAttach); + } + role.setUserTestProjectRoleList(attachedUserTestProjectRoleList); + List attachedUserTestPlanRoleList = new ArrayList<>(); + for (UserTestPlanRole userTestPlanRoleListUserTestPlanRoleToAttach : role.getUserTestPlanRoleList()) { + userTestPlanRoleListUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListUserTestPlanRoleToAttach.getUserTestPlanRolePK()); + attachedUserTestPlanRoleList.add(userTestPlanRoleListUserTestPlanRoleToAttach); + } + role.setUserTestPlanRoleList(attachedUserTestPlanRoleList); + List attachedExecutionStepHasVmUserList = new ArrayList<>(); + for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUserToAttach : role.getExecutionStepHasVmUserList()) { + executionStepHasVmUserListExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); + attachedExecutionStepHasVmUserList.add(executionStepHasVmUserListExecutionStepHasVmUserToAttach); + } + role.setExecutionStepHasVmUserList(attachedExecutionStepHasVmUserList); + em.persist(role); + for (VmUser vmUserListVmUser : role.getVmUserList()) { + vmUserListVmUser.getRoleList().add(role); + vmUserListVmUser = em.merge(vmUserListVmUser); + } + for (UserRight userRightListUserRight : role.getUserRightList()) { + userRightListUserRight.getRoleList().add(role); + userRightListUserRight = em.merge(userRightListUserRight); + } + for (UserTestProjectRole userTestProjectRoleListUserTestProjectRole : role.getUserTestProjectRoleList()) { + Role oldRoleOfUserTestProjectRoleListUserTestProjectRole = userTestProjectRoleListUserTestProjectRole.getRole(); + userTestProjectRoleListUserTestProjectRole.setRole(role); + userTestProjectRoleListUserTestProjectRole = em.merge(userTestProjectRoleListUserTestProjectRole); + if (oldRoleOfUserTestProjectRoleListUserTestProjectRole != null) { + oldRoleOfUserTestProjectRoleListUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListUserTestProjectRole); + oldRoleOfUserTestProjectRoleListUserTestProjectRole = em.merge(oldRoleOfUserTestProjectRoleListUserTestProjectRole); + } + } + for (UserTestPlanRole userTestPlanRoleListUserTestPlanRole : role.getUserTestPlanRoleList()) { + Role oldRoleOfUserTestPlanRoleListUserTestPlanRole = userTestPlanRoleListUserTestPlanRole.getRole(); + userTestPlanRoleListUserTestPlanRole.setRole(role); + userTestPlanRoleListUserTestPlanRole = em.merge(userTestPlanRoleListUserTestPlanRole); + if (oldRoleOfUserTestPlanRoleListUserTestPlanRole != null) { + oldRoleOfUserTestPlanRoleListUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListUserTestPlanRole); + oldRoleOfUserTestPlanRoleListUserTestPlanRole = em.merge(oldRoleOfUserTestPlanRoleListUserTestPlanRole); + } + } + for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUser : role.getExecutionStepHasVmUserList()) { + Role oldRoleOfExecutionStepHasVmUserListExecutionStepHasVmUser = executionStepHasVmUserListExecutionStepHasVmUser.getRole(); + executionStepHasVmUserListExecutionStepHasVmUser.setRole(role); + executionStepHasVmUserListExecutionStepHasVmUser = em.merge(executionStepHasVmUserListExecutionStepHasVmUser); + if (oldRoleOfExecutionStepHasVmUserListExecutionStepHasVmUser != null) { + oldRoleOfExecutionStepHasVmUserListExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListExecutionStepHasVmUser); + oldRoleOfExecutionStepHasVmUserListExecutionStepHasVmUser = em.merge(oldRoleOfExecutionStepHasVmUserListExecutionStepHasVmUser); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(Role role) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Role persistentRole = em.find(Role.class, role.getId()); + List vmUserListOld = persistentRole.getVmUserList(); + List vmUserListNew = role.getVmUserList(); + List userRightListOld = persistentRole.getUserRightList(); + List userRightListNew = role.getUserRightList(); + List userTestProjectRoleListOld = persistentRole.getUserTestProjectRoleList(); + List userTestProjectRoleListNew = role.getUserTestProjectRoleList(); + List userTestPlanRoleListOld = persistentRole.getUserTestPlanRoleList(); + List userTestPlanRoleListNew = role.getUserTestPlanRoleList(); + List executionStepHasVmUserListOld = persistentRole.getExecutionStepHasVmUserList(); + List executionStepHasVmUserListNew = role.getExecutionStepHasVmUserList(); + List illegalOrphanMessages = null; + for (UserTestProjectRole userTestProjectRoleListOldUserTestProjectRole : userTestProjectRoleListOld) { + if (!userTestProjectRoleListNew.contains(userTestProjectRoleListOldUserTestProjectRole)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserTestProjectRole " + userTestProjectRoleListOldUserTestProjectRole + " since its role field is not nullable."); + } + } + for (UserTestPlanRole userTestPlanRoleListOldUserTestPlanRole : userTestPlanRoleListOld) { + if (!userTestPlanRoleListNew.contains(userTestPlanRoleListOldUserTestPlanRole)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserTestPlanRole " + userTestPlanRoleListOldUserTestPlanRole + " since its role field is not nullable."); + } + } + for (ExecutionStepHasVmUser executionStepHasVmUserListOldExecutionStepHasVmUser : executionStepHasVmUserListOld) { + if (!executionStepHasVmUserListNew.contains(executionStepHasVmUserListOldExecutionStepHasVmUser)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExecutionStepHasVmUser " + executionStepHasVmUserListOldExecutionStepHasVmUser + " since its role field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedVmUserListNew = new ArrayList<>(); + for (VmUser vmUserListNewVmUserToAttach : vmUserListNew) { + vmUserListNewVmUserToAttach = em.getReference(vmUserListNewVmUserToAttach.getClass(), vmUserListNewVmUserToAttach.getId()); + attachedVmUserListNew.add(vmUserListNewVmUserToAttach); + } + vmUserListNew = attachedVmUserListNew; + role.setVmUserList(vmUserListNew); + List attachedUserRightListNew = new ArrayList<>(); + for (UserRight userRightListNewUserRightToAttach : userRightListNew) { + userRightListNewUserRightToAttach = em.getReference(userRightListNewUserRightToAttach.getClass(), userRightListNewUserRightToAttach.getId()); + attachedUserRightListNew.add(userRightListNewUserRightToAttach); + } + userRightListNew = attachedUserRightListNew; + role.setUserRightList(userRightListNew); + List attachedUserTestProjectRoleListNew = new ArrayList<>(); + for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRoleToAttach : userTestProjectRoleListNew) { + userTestProjectRoleListNewUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListNewUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListNewUserTestProjectRoleToAttach.getUserTestProjectRolePK()); + attachedUserTestProjectRoleListNew.add(userTestProjectRoleListNewUserTestProjectRoleToAttach); + } + userTestProjectRoleListNew = attachedUserTestProjectRoleListNew; + role.setUserTestProjectRoleList(userTestProjectRoleListNew); + List attachedUserTestPlanRoleListNew = new ArrayList<>(); + for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRoleToAttach : userTestPlanRoleListNew) { + userTestPlanRoleListNewUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListNewUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListNewUserTestPlanRoleToAttach.getUserTestPlanRolePK()); + attachedUserTestPlanRoleListNew.add(userTestPlanRoleListNewUserTestPlanRoleToAttach); + } + userTestPlanRoleListNew = attachedUserTestPlanRoleListNew; + role.setUserTestPlanRoleList(userTestPlanRoleListNew); + List attachedExecutionStepHasVmUserListNew = new ArrayList<>(); + for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUserToAttach : executionStepHasVmUserListNew) { + executionStepHasVmUserListNewExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); + attachedExecutionStepHasVmUserListNew.add(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach); + } + executionStepHasVmUserListNew = attachedExecutionStepHasVmUserListNew; + role.setExecutionStepHasVmUserList(executionStepHasVmUserListNew); + role = em.merge(role); + for (VmUser vmUserListOldVmUser : vmUserListOld) { + if (!vmUserListNew.contains(vmUserListOldVmUser)) { + vmUserListOldVmUser.getRoleList().remove(role); + vmUserListOldVmUser = em.merge(vmUserListOldVmUser); + } + } + for (VmUser vmUserListNewVmUser : vmUserListNew) { + if (!vmUserListOld.contains(vmUserListNewVmUser)) { + vmUserListNewVmUser.getRoleList().add(role); + vmUserListNewVmUser = em.merge(vmUserListNewVmUser); + } + } + for (UserRight userRightListOldUserRight : userRightListOld) { + if (!userRightListNew.contains(userRightListOldUserRight)) { + userRightListOldUserRight.getRoleList().remove(role); + userRightListOldUserRight = em.merge(userRightListOldUserRight); + } + } + for (UserRight userRightListNewUserRight : userRightListNew) { + if (!userRightListOld.contains(userRightListNewUserRight)) { + userRightListNewUserRight.getRoleList().add(role); + userRightListNewUserRight = em.merge(userRightListNewUserRight); + } + } + for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRole : userTestProjectRoleListNew) { + if (!userTestProjectRoleListOld.contains(userTestProjectRoleListNewUserTestProjectRole)) { + Role oldRoleOfUserTestProjectRoleListNewUserTestProjectRole = userTestProjectRoleListNewUserTestProjectRole.getRole(); + userTestProjectRoleListNewUserTestProjectRole.setRole(role); + userTestProjectRoleListNewUserTestProjectRole = em.merge(userTestProjectRoleListNewUserTestProjectRole); + if (oldRoleOfUserTestProjectRoleListNewUserTestProjectRole != null && !oldRoleOfUserTestProjectRoleListNewUserTestProjectRole.equals(role)) { + oldRoleOfUserTestProjectRoleListNewUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListNewUserTestProjectRole); + oldRoleOfUserTestProjectRoleListNewUserTestProjectRole = em.merge(oldRoleOfUserTestProjectRoleListNewUserTestProjectRole); + } + } + } + for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRole : userTestPlanRoleListNew) { + if (!userTestPlanRoleListOld.contains(userTestPlanRoleListNewUserTestPlanRole)) { + Role oldRoleOfUserTestPlanRoleListNewUserTestPlanRole = userTestPlanRoleListNewUserTestPlanRole.getRole(); + userTestPlanRoleListNewUserTestPlanRole.setRole(role); + userTestPlanRoleListNewUserTestPlanRole = em.merge(userTestPlanRoleListNewUserTestPlanRole); + if (oldRoleOfUserTestPlanRoleListNewUserTestPlanRole != null && !oldRoleOfUserTestPlanRoleListNewUserTestPlanRole.equals(role)) { + oldRoleOfUserTestPlanRoleListNewUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListNewUserTestPlanRole); + oldRoleOfUserTestPlanRoleListNewUserTestPlanRole = em.merge(oldRoleOfUserTestPlanRoleListNewUserTestPlanRole); + } + } + } + for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUser : executionStepHasVmUserListNew) { + if (!executionStepHasVmUserListOld.contains(executionStepHasVmUserListNewExecutionStepHasVmUser)) { + Role oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = executionStepHasVmUserListNewExecutionStepHasVmUser.getRole(); + executionStepHasVmUserListNewExecutionStepHasVmUser.setRole(role); + executionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(executionStepHasVmUserListNewExecutionStepHasVmUser); + if (oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser != null && !oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.equals(role)) { + oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListNewExecutionStepHasVmUser); + oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(oldRoleOfExecutionStepHasVmUserListNewExecutionStepHasVmUser); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = role.getId(); + if (findRole(id) == null) { + throw new NonexistentEntityException("The role with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Role role; + try { + role = em.getReference(Role.class, id); + role.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The role with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List userTestProjectRoleListOrphanCheck = role.getUserTestProjectRoleList(); + for (UserTestProjectRole userTestProjectRoleListOrphanCheckUserTestProjectRole : userTestProjectRoleListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Role (" + role + ") cannot be destroyed since the UserTestProjectRole " + userTestProjectRoleListOrphanCheckUserTestProjectRole + " in its userTestProjectRoleList field has a non-nullable role field."); + } + List userTestPlanRoleListOrphanCheck = role.getUserTestPlanRoleList(); + for (UserTestPlanRole userTestPlanRoleListOrphanCheckUserTestPlanRole : userTestPlanRoleListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Role (" + role + ") cannot be destroyed since the UserTestPlanRole " + userTestPlanRoleListOrphanCheckUserTestPlanRole + " in its userTestPlanRoleList field has a non-nullable role field."); + } + List executionStepHasVmUserListOrphanCheck = role.getExecutionStepHasVmUserList(); + for (ExecutionStepHasVmUser executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser : executionStepHasVmUserListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Role (" + role + ") cannot be destroyed since the ExecutionStepHasVmUser " + executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser + " in its executionStepHasVmUserList field has a non-nullable role field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List vmUserList = role.getVmUserList(); + for (VmUser vmUserListVmUser : vmUserList) { + vmUserListVmUser.getRoleList().remove(role); + vmUserListVmUser = em.merge(vmUserListVmUser); + } + List userRightList = role.getUserRightList(); + for (UserRight userRightListUserRight : userRightList) { + userRightListUserRight.getRoleList().remove(role); + userRightListUserRight = em.merge(userRightListUserRight); + } + em.remove(role); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRoleEntities() { + return findRoleEntities(true, -1, -1); + } + + public List findRoleEntities(int maxResults, int firstResult) { + return findRoleEntities(false, maxResults, firstResult); + } + + private List findRoleEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(Role.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public Role findRole(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(Role.class, id); + } + finally { + em.close(); + } + } + + public int getRoleCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(Role.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RootCauseJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RootCauseJpaController.java index 08e0e7fb..5f130858 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RootCauseJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RootCauseJpaController.java @@ -13,291 +13,291 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.RootCauseType; -import com.validation.manager.core.db.VmUser; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.ExceptionHasRootCause; -import com.validation.manager.core.db.RootCause; -import com.validation.manager.core.db.RootCausePK; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RootCauseJpaController implements Serializable { - - public RootCauseJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(RootCause rootCause) throws PreexistingEntityException, Exception { - if (rootCause.getRootCausePK() == null) { - rootCause.setRootCausePK(new RootCausePK()); - } - if (rootCause.getVmUserList() == null) { - rootCause.setVmUserList(new ArrayList()); - } - if (rootCause.getExceptionHasRootCauseList() == null) { - rootCause.setExceptionHasRootCauseList(new ArrayList()); - } - rootCause.getRootCausePK().setRootCauseTypeId(rootCause.getRootCauseType().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RootCauseType rootCauseType = rootCause.getRootCauseType(); - if (rootCauseType != null) { - rootCauseType = em.getReference(rootCauseType.getClass(), rootCauseType.getId()); - rootCause.setRootCauseType(rootCauseType); - } - List attachedVmUserList = new ArrayList(); - for (VmUser vmUserListVmUserToAttach : rootCause.getVmUserList()) { - vmUserListVmUserToAttach = em.getReference(vmUserListVmUserToAttach.getClass(), vmUserListVmUserToAttach.getId()); - attachedVmUserList.add(vmUserListVmUserToAttach); - } - rootCause.setVmUserList(attachedVmUserList); - List attachedExceptionHasRootCauseList = new ArrayList(); - for (ExceptionHasRootCause exceptionHasRootCauseListExceptionHasRootCauseToAttach : rootCause.getExceptionHasRootCauseList()) { - exceptionHasRootCauseListExceptionHasRootCauseToAttach = em.getReference(exceptionHasRootCauseListExceptionHasRootCauseToAttach.getClass(), exceptionHasRootCauseListExceptionHasRootCauseToAttach.getExceptionHasRootCausePK()); - attachedExceptionHasRootCauseList.add(exceptionHasRootCauseListExceptionHasRootCauseToAttach); - } - rootCause.setExceptionHasRootCauseList(attachedExceptionHasRootCauseList); - em.persist(rootCause); - if (rootCauseType != null) { - rootCauseType.getRootCauseList().add(rootCause); - rootCauseType = em.merge(rootCauseType); - } - for (VmUser vmUserListVmUser : rootCause.getVmUserList()) { - vmUserListVmUser.getRootCauseList().add(rootCause); - vmUserListVmUser = em.merge(vmUserListVmUser); - } - for (ExceptionHasRootCause exceptionHasRootCauseListExceptionHasRootCause : rootCause.getExceptionHasRootCauseList()) { - RootCause oldRootCauseOfExceptionHasRootCauseListExceptionHasRootCause = exceptionHasRootCauseListExceptionHasRootCause.getRootCause(); - exceptionHasRootCauseListExceptionHasRootCause.setRootCause(rootCause); - exceptionHasRootCauseListExceptionHasRootCause = em.merge(exceptionHasRootCauseListExceptionHasRootCause); - if (oldRootCauseOfExceptionHasRootCauseListExceptionHasRootCause != null) { - oldRootCauseOfExceptionHasRootCauseListExceptionHasRootCause.getExceptionHasRootCauseList().remove(exceptionHasRootCauseListExceptionHasRootCause); - oldRootCauseOfExceptionHasRootCauseListExceptionHasRootCause = em.merge(oldRootCauseOfExceptionHasRootCauseListExceptionHasRootCause); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findRootCause(rootCause.getRootCausePK()) != null) { - throw new PreexistingEntityException("RootCause " + rootCause + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(RootCause rootCause) throws IllegalOrphanException, NonexistentEntityException, Exception { - rootCause.getRootCausePK().setRootCauseTypeId(rootCause.getRootCauseType().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RootCause persistentRootCause = em.find(RootCause.class, rootCause.getRootCausePK()); - RootCauseType rootCauseTypeOld = persistentRootCause.getRootCauseType(); - RootCauseType rootCauseTypeNew = rootCause.getRootCauseType(); - List vmUserListOld = persistentRootCause.getVmUserList(); - List vmUserListNew = rootCause.getVmUserList(); - List exceptionHasRootCauseListOld = persistentRootCause.getExceptionHasRootCauseList(); - List exceptionHasRootCauseListNew = rootCause.getExceptionHasRootCauseList(); - List illegalOrphanMessages = null; - for (ExceptionHasRootCause exceptionHasRootCauseListOldExceptionHasRootCause : exceptionHasRootCauseListOld) { - if (!exceptionHasRootCauseListNew.contains(exceptionHasRootCauseListOldExceptionHasRootCause)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExceptionHasRootCause " + exceptionHasRootCauseListOldExceptionHasRootCause + " since its rootCause field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (rootCauseTypeNew != null) { - rootCauseTypeNew = em.getReference(rootCauseTypeNew.getClass(), rootCauseTypeNew.getId()); - rootCause.setRootCauseType(rootCauseTypeNew); - } - List attachedVmUserListNew = new ArrayList(); - for (VmUser vmUserListNewVmUserToAttach : vmUserListNew) { - vmUserListNewVmUserToAttach = em.getReference(vmUserListNewVmUserToAttach.getClass(), vmUserListNewVmUserToAttach.getId()); - attachedVmUserListNew.add(vmUserListNewVmUserToAttach); - } - vmUserListNew = attachedVmUserListNew; - rootCause.setVmUserList(vmUserListNew); - List attachedExceptionHasRootCauseListNew = new ArrayList(); - for (ExceptionHasRootCause exceptionHasRootCauseListNewExceptionHasRootCauseToAttach : exceptionHasRootCauseListNew) { - exceptionHasRootCauseListNewExceptionHasRootCauseToAttach = em.getReference(exceptionHasRootCauseListNewExceptionHasRootCauseToAttach.getClass(), exceptionHasRootCauseListNewExceptionHasRootCauseToAttach.getExceptionHasRootCausePK()); - attachedExceptionHasRootCauseListNew.add(exceptionHasRootCauseListNewExceptionHasRootCauseToAttach); - } - exceptionHasRootCauseListNew = attachedExceptionHasRootCauseListNew; - rootCause.setExceptionHasRootCauseList(exceptionHasRootCauseListNew); - rootCause = em.merge(rootCause); - if (rootCauseTypeOld != null && !rootCauseTypeOld.equals(rootCauseTypeNew)) { - rootCauseTypeOld.getRootCauseList().remove(rootCause); - rootCauseTypeOld = em.merge(rootCauseTypeOld); - } - if (rootCauseTypeNew != null && !rootCauseTypeNew.equals(rootCauseTypeOld)) { - rootCauseTypeNew.getRootCauseList().add(rootCause); - rootCauseTypeNew = em.merge(rootCauseTypeNew); - } - for (VmUser vmUserListOldVmUser : vmUserListOld) { - if (!vmUserListNew.contains(vmUserListOldVmUser)) { - vmUserListOldVmUser.getRootCauseList().remove(rootCause); - vmUserListOldVmUser = em.merge(vmUserListOldVmUser); - } - } - for (VmUser vmUserListNewVmUser : vmUserListNew) { - if (!vmUserListOld.contains(vmUserListNewVmUser)) { - vmUserListNewVmUser.getRootCauseList().add(rootCause); - vmUserListNewVmUser = em.merge(vmUserListNewVmUser); - } - } - for (ExceptionHasRootCause exceptionHasRootCauseListNewExceptionHasRootCause : exceptionHasRootCauseListNew) { - if (!exceptionHasRootCauseListOld.contains(exceptionHasRootCauseListNewExceptionHasRootCause)) { - RootCause oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause = exceptionHasRootCauseListNewExceptionHasRootCause.getRootCause(); - exceptionHasRootCauseListNewExceptionHasRootCause.setRootCause(rootCause); - exceptionHasRootCauseListNewExceptionHasRootCause = em.merge(exceptionHasRootCauseListNewExceptionHasRootCause); - if (oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause != null && !oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause.equals(rootCause)) { - oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause.getExceptionHasRootCauseList().remove(exceptionHasRootCauseListNewExceptionHasRootCause); - oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause = em.merge(oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - RootCausePK id = rootCause.getRootCausePK(); - if (findRootCause(id) == null) { - throw new NonexistentEntityException("The rootCause with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(RootCausePK id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RootCause rootCause; - try { - rootCause = em.getReference(RootCause.class, id); - rootCause.getRootCausePK(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The rootCause with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List exceptionHasRootCauseListOrphanCheck = rootCause.getExceptionHasRootCauseList(); - for (ExceptionHasRootCause exceptionHasRootCauseListOrphanCheckExceptionHasRootCause : exceptionHasRootCauseListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RootCause (" + rootCause + ") cannot be destroyed since the ExceptionHasRootCause " + exceptionHasRootCauseListOrphanCheckExceptionHasRootCause + " in its exceptionHasRootCauseList field has a non-nullable rootCause field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - RootCauseType rootCauseType = rootCause.getRootCauseType(); - if (rootCauseType != null) { - rootCauseType.getRootCauseList().remove(rootCause); - rootCauseType = em.merge(rootCauseType); - } - List vmUserList = rootCause.getVmUserList(); - for (VmUser vmUserListVmUser : vmUserList) { - vmUserListVmUser.getRootCauseList().remove(rootCause); - vmUserListVmUser = em.merge(vmUserListVmUser); - } - em.remove(rootCause); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRootCauseEntities() { - return findRootCauseEntities(true, -1, -1); - } - - public List findRootCauseEntities(int maxResults, int firstResult) { - return findRootCauseEntities(false, maxResults, firstResult); - } - - private List findRootCauseEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(RootCause.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public RootCause findRootCause(RootCausePK id) { - EntityManager em = getEntityManager(); - try { - return em.find(RootCause.class, id); - } - finally { - em.close(); - } - } - - public int getRootCauseCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(RootCause.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.RootCauseType; +import com.validation.manager.core.db.VmUser; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.ExceptionHasRootCause; +import com.validation.manager.core.db.RootCause; +import com.validation.manager.core.db.RootCausePK; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RootCauseJpaController implements Serializable { + + public RootCauseJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(RootCause rootCause) throws PreexistingEntityException, Exception { + if (rootCause.getRootCausePK() == null) { + rootCause.setRootCausePK(new RootCausePK()); + } + if (rootCause.getVmUserList() == null) { + rootCause.setVmUserList(new ArrayList<>()); + } + if (rootCause.getExceptionHasRootCauseList() == null) { + rootCause.setExceptionHasRootCauseList(new ArrayList<>()); + } + rootCause.getRootCausePK().setRootCauseTypeId(rootCause.getRootCauseType().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RootCauseType rootCauseType = rootCause.getRootCauseType(); + if (rootCauseType != null) { + rootCauseType = em.getReference(rootCauseType.getClass(), rootCauseType.getId()); + rootCause.setRootCauseType(rootCauseType); + } + List attachedVmUserList = new ArrayList<>(); + for (VmUser vmUserListVmUserToAttach : rootCause.getVmUserList()) { + vmUserListVmUserToAttach = em.getReference(vmUserListVmUserToAttach.getClass(), vmUserListVmUserToAttach.getId()); + attachedVmUserList.add(vmUserListVmUserToAttach); + } + rootCause.setVmUserList(attachedVmUserList); + List attachedExceptionHasRootCauseList = new ArrayList<>(); + for (ExceptionHasRootCause exceptionHasRootCauseListExceptionHasRootCauseToAttach : rootCause.getExceptionHasRootCauseList()) { + exceptionHasRootCauseListExceptionHasRootCauseToAttach = em.getReference(exceptionHasRootCauseListExceptionHasRootCauseToAttach.getClass(), exceptionHasRootCauseListExceptionHasRootCauseToAttach.getExceptionHasRootCausePK()); + attachedExceptionHasRootCauseList.add(exceptionHasRootCauseListExceptionHasRootCauseToAttach); + } + rootCause.setExceptionHasRootCauseList(attachedExceptionHasRootCauseList); + em.persist(rootCause); + if (rootCauseType != null) { + rootCauseType.getRootCauseList().add(rootCause); + rootCauseType = em.merge(rootCauseType); + } + for (VmUser vmUserListVmUser : rootCause.getVmUserList()) { + vmUserListVmUser.getRootCauseList().add(rootCause); + vmUserListVmUser = em.merge(vmUserListVmUser); + } + for (ExceptionHasRootCause exceptionHasRootCauseListExceptionHasRootCause : rootCause.getExceptionHasRootCauseList()) { + RootCause oldRootCauseOfExceptionHasRootCauseListExceptionHasRootCause = exceptionHasRootCauseListExceptionHasRootCause.getRootCause(); + exceptionHasRootCauseListExceptionHasRootCause.setRootCause(rootCause); + exceptionHasRootCauseListExceptionHasRootCause = em.merge(exceptionHasRootCauseListExceptionHasRootCause); + if (oldRootCauseOfExceptionHasRootCauseListExceptionHasRootCause != null) { + oldRootCauseOfExceptionHasRootCauseListExceptionHasRootCause.getExceptionHasRootCauseList().remove(exceptionHasRootCauseListExceptionHasRootCause); + oldRootCauseOfExceptionHasRootCauseListExceptionHasRootCause = em.merge(oldRootCauseOfExceptionHasRootCauseListExceptionHasRootCause); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findRootCause(rootCause.getRootCausePK()) != null) { + throw new PreexistingEntityException("RootCause " + rootCause + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(RootCause rootCause) throws IllegalOrphanException, NonexistentEntityException, Exception { + rootCause.getRootCausePK().setRootCauseTypeId(rootCause.getRootCauseType().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RootCause persistentRootCause = em.find(RootCause.class, rootCause.getRootCausePK()); + RootCauseType rootCauseTypeOld = persistentRootCause.getRootCauseType(); + RootCauseType rootCauseTypeNew = rootCause.getRootCauseType(); + List vmUserListOld = persistentRootCause.getVmUserList(); + List vmUserListNew = rootCause.getVmUserList(); + List exceptionHasRootCauseListOld = persistentRootCause.getExceptionHasRootCauseList(); + List exceptionHasRootCauseListNew = rootCause.getExceptionHasRootCauseList(); + List illegalOrphanMessages = null; + for (ExceptionHasRootCause exceptionHasRootCauseListOldExceptionHasRootCause : exceptionHasRootCauseListOld) { + if (!exceptionHasRootCauseListNew.contains(exceptionHasRootCauseListOldExceptionHasRootCause)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExceptionHasRootCause " + exceptionHasRootCauseListOldExceptionHasRootCause + " since its rootCause field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (rootCauseTypeNew != null) { + rootCauseTypeNew = em.getReference(rootCauseTypeNew.getClass(), rootCauseTypeNew.getId()); + rootCause.setRootCauseType(rootCauseTypeNew); + } + List attachedVmUserListNew = new ArrayList<>(); + for (VmUser vmUserListNewVmUserToAttach : vmUserListNew) { + vmUserListNewVmUserToAttach = em.getReference(vmUserListNewVmUserToAttach.getClass(), vmUserListNewVmUserToAttach.getId()); + attachedVmUserListNew.add(vmUserListNewVmUserToAttach); + } + vmUserListNew = attachedVmUserListNew; + rootCause.setVmUserList(vmUserListNew); + List attachedExceptionHasRootCauseListNew = new ArrayList<>(); + for (ExceptionHasRootCause exceptionHasRootCauseListNewExceptionHasRootCauseToAttach : exceptionHasRootCauseListNew) { + exceptionHasRootCauseListNewExceptionHasRootCauseToAttach = em.getReference(exceptionHasRootCauseListNewExceptionHasRootCauseToAttach.getClass(), exceptionHasRootCauseListNewExceptionHasRootCauseToAttach.getExceptionHasRootCausePK()); + attachedExceptionHasRootCauseListNew.add(exceptionHasRootCauseListNewExceptionHasRootCauseToAttach); + } + exceptionHasRootCauseListNew = attachedExceptionHasRootCauseListNew; + rootCause.setExceptionHasRootCauseList(exceptionHasRootCauseListNew); + rootCause = em.merge(rootCause); + if (rootCauseTypeOld != null && !rootCauseTypeOld.equals(rootCauseTypeNew)) { + rootCauseTypeOld.getRootCauseList().remove(rootCause); + rootCauseTypeOld = em.merge(rootCauseTypeOld); + } + if (rootCauseTypeNew != null && !rootCauseTypeNew.equals(rootCauseTypeOld)) { + rootCauseTypeNew.getRootCauseList().add(rootCause); + rootCauseTypeNew = em.merge(rootCauseTypeNew); + } + for (VmUser vmUserListOldVmUser : vmUserListOld) { + if (!vmUserListNew.contains(vmUserListOldVmUser)) { + vmUserListOldVmUser.getRootCauseList().remove(rootCause); + vmUserListOldVmUser = em.merge(vmUserListOldVmUser); + } + } + for (VmUser vmUserListNewVmUser : vmUserListNew) { + if (!vmUserListOld.contains(vmUserListNewVmUser)) { + vmUserListNewVmUser.getRootCauseList().add(rootCause); + vmUserListNewVmUser = em.merge(vmUserListNewVmUser); + } + } + for (ExceptionHasRootCause exceptionHasRootCauseListNewExceptionHasRootCause : exceptionHasRootCauseListNew) { + if (!exceptionHasRootCauseListOld.contains(exceptionHasRootCauseListNewExceptionHasRootCause)) { + RootCause oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause = exceptionHasRootCauseListNewExceptionHasRootCause.getRootCause(); + exceptionHasRootCauseListNewExceptionHasRootCause.setRootCause(rootCause); + exceptionHasRootCauseListNewExceptionHasRootCause = em.merge(exceptionHasRootCauseListNewExceptionHasRootCause); + if (oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause != null && !oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause.equals(rootCause)) { + oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause.getExceptionHasRootCauseList().remove(exceptionHasRootCauseListNewExceptionHasRootCause); + oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause = em.merge(oldRootCauseOfExceptionHasRootCauseListNewExceptionHasRootCause); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + RootCausePK id = rootCause.getRootCausePK(); + if (findRootCause(id) == null) { + throw new NonexistentEntityException("The rootCause with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(RootCausePK id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RootCause rootCause; + try { + rootCause = em.getReference(RootCause.class, id); + rootCause.getRootCausePK(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The rootCause with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List exceptionHasRootCauseListOrphanCheck = rootCause.getExceptionHasRootCauseList(); + for (ExceptionHasRootCause exceptionHasRootCauseListOrphanCheckExceptionHasRootCause : exceptionHasRootCauseListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RootCause (" + rootCause + ") cannot be destroyed since the ExceptionHasRootCause " + exceptionHasRootCauseListOrphanCheckExceptionHasRootCause + " in its exceptionHasRootCauseList field has a non-nullable rootCause field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + RootCauseType rootCauseType = rootCause.getRootCauseType(); + if (rootCauseType != null) { + rootCauseType.getRootCauseList().remove(rootCause); + rootCauseType = em.merge(rootCauseType); + } + List vmUserList = rootCause.getVmUserList(); + for (VmUser vmUserListVmUser : vmUserList) { + vmUserListVmUser.getRootCauseList().remove(rootCause); + vmUserListVmUser = em.merge(vmUserListVmUser); + } + em.remove(rootCause); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRootCauseEntities() { + return findRootCauseEntities(true, -1, -1); + } + + public List findRootCauseEntities(int maxResults, int firstResult) { + return findRootCauseEntities(false, maxResults, firstResult); + } + + private List findRootCauseEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(RootCause.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public RootCause findRootCause(RootCausePK id) { + EntityManager em = getEntityManager(); + try { + return em.find(RootCause.class, id); + } + finally { + em.close(); + } + } + + public int getRootCauseCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(RootCause.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RootCauseTypeJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RootCauseTypeJpaController.java index 863498ef..d4b19ace 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/RootCauseTypeJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/RootCauseTypeJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.RootCause; -import com.validation.manager.core.db.RootCauseType; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RootCauseTypeJpaController implements Serializable { - - public RootCauseTypeJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(RootCauseType rootCauseType) { - if (rootCauseType.getRootCauseList() == null) { - rootCauseType.setRootCauseList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedRootCauseList = new ArrayList(); - for (RootCause rootCauseListRootCauseToAttach : rootCauseType.getRootCauseList()) { - rootCauseListRootCauseToAttach = em.getReference(rootCauseListRootCauseToAttach.getClass(), rootCauseListRootCauseToAttach.getRootCausePK()); - attachedRootCauseList.add(rootCauseListRootCauseToAttach); - } - rootCauseType.setRootCauseList(attachedRootCauseList); - em.persist(rootCauseType); - for (RootCause rootCauseListRootCause : rootCauseType.getRootCauseList()) { - RootCauseType oldRootCauseTypeOfRootCauseListRootCause = rootCauseListRootCause.getRootCauseType(); - rootCauseListRootCause.setRootCauseType(rootCauseType); - rootCauseListRootCause = em.merge(rootCauseListRootCause); - if (oldRootCauseTypeOfRootCauseListRootCause != null) { - oldRootCauseTypeOfRootCauseListRootCause.getRootCauseList().remove(rootCauseListRootCause); - oldRootCauseTypeOfRootCauseListRootCause = em.merge(oldRootCauseTypeOfRootCauseListRootCause); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(RootCauseType rootCauseType) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RootCauseType persistentRootCauseType = em.find(RootCauseType.class, rootCauseType.getId()); - List rootCauseListOld = persistentRootCauseType.getRootCauseList(); - List rootCauseListNew = rootCauseType.getRootCauseList(); - List illegalOrphanMessages = null; - for (RootCause rootCauseListOldRootCause : rootCauseListOld) { - if (!rootCauseListNew.contains(rootCauseListOldRootCause)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RootCause " + rootCauseListOldRootCause + " since its rootCauseType field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedRootCauseListNew = new ArrayList(); - for (RootCause rootCauseListNewRootCauseToAttach : rootCauseListNew) { - rootCauseListNewRootCauseToAttach = em.getReference(rootCauseListNewRootCauseToAttach.getClass(), rootCauseListNewRootCauseToAttach.getRootCausePK()); - attachedRootCauseListNew.add(rootCauseListNewRootCauseToAttach); - } - rootCauseListNew = attachedRootCauseListNew; - rootCauseType.setRootCauseList(rootCauseListNew); - rootCauseType = em.merge(rootCauseType); - for (RootCause rootCauseListNewRootCause : rootCauseListNew) { - if (!rootCauseListOld.contains(rootCauseListNewRootCause)) { - RootCauseType oldRootCauseTypeOfRootCauseListNewRootCause = rootCauseListNewRootCause.getRootCauseType(); - rootCauseListNewRootCause.setRootCauseType(rootCauseType); - rootCauseListNewRootCause = em.merge(rootCauseListNewRootCause); - if (oldRootCauseTypeOfRootCauseListNewRootCause != null && !oldRootCauseTypeOfRootCauseListNewRootCause.equals(rootCauseType)) { - oldRootCauseTypeOfRootCauseListNewRootCause.getRootCauseList().remove(rootCauseListNewRootCause); - oldRootCauseTypeOfRootCauseListNewRootCause = em.merge(oldRootCauseTypeOfRootCauseListNewRootCause); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = rootCauseType.getId(); - if (findRootCauseType(id) == null) { - throw new NonexistentEntityException("The rootCauseType with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - RootCauseType rootCauseType; - try { - rootCauseType = em.getReference(RootCauseType.class, id); - rootCauseType.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The rootCauseType with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List rootCauseListOrphanCheck = rootCauseType.getRootCauseList(); - for (RootCause rootCauseListOrphanCheckRootCause : rootCauseListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This RootCauseType (" + rootCauseType + ") cannot be destroyed since the RootCause " + rootCauseListOrphanCheckRootCause + " in its rootCauseList field has a non-nullable rootCauseType field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(rootCauseType); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findRootCauseTypeEntities() { - return findRootCauseTypeEntities(true, -1, -1); - } - - public List findRootCauseTypeEntities(int maxResults, int firstResult) { - return findRootCauseTypeEntities(false, maxResults, firstResult); - } - - private List findRootCauseTypeEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(RootCauseType.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public RootCauseType findRootCauseType(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(RootCauseType.class, id); - } - finally { - em.close(); - } - } - - public int getRootCauseTypeCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(RootCauseType.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.RootCause; +import com.validation.manager.core.db.RootCauseType; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RootCauseTypeJpaController implements Serializable { + + public RootCauseTypeJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(RootCauseType rootCauseType) { + if (rootCauseType.getRootCauseList() == null) { + rootCauseType.setRootCauseList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedRootCauseList = new ArrayList<>(); + for (RootCause rootCauseListRootCauseToAttach : rootCauseType.getRootCauseList()) { + rootCauseListRootCauseToAttach = em.getReference(rootCauseListRootCauseToAttach.getClass(), rootCauseListRootCauseToAttach.getRootCausePK()); + attachedRootCauseList.add(rootCauseListRootCauseToAttach); + } + rootCauseType.setRootCauseList(attachedRootCauseList); + em.persist(rootCauseType); + for (RootCause rootCauseListRootCause : rootCauseType.getRootCauseList()) { + RootCauseType oldRootCauseTypeOfRootCauseListRootCause = rootCauseListRootCause.getRootCauseType(); + rootCauseListRootCause.setRootCauseType(rootCauseType); + rootCauseListRootCause = em.merge(rootCauseListRootCause); + if (oldRootCauseTypeOfRootCauseListRootCause != null) { + oldRootCauseTypeOfRootCauseListRootCause.getRootCauseList().remove(rootCauseListRootCause); + oldRootCauseTypeOfRootCauseListRootCause = em.merge(oldRootCauseTypeOfRootCauseListRootCause); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(RootCauseType rootCauseType) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RootCauseType persistentRootCauseType = em.find(RootCauseType.class, rootCauseType.getId()); + List rootCauseListOld = persistentRootCauseType.getRootCauseList(); + List rootCauseListNew = rootCauseType.getRootCauseList(); + List illegalOrphanMessages = null; + for (RootCause rootCauseListOldRootCause : rootCauseListOld) { + if (!rootCauseListNew.contains(rootCauseListOldRootCause)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RootCause " + rootCauseListOldRootCause + " since its rootCauseType field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedRootCauseListNew = new ArrayList<>(); + for (RootCause rootCauseListNewRootCauseToAttach : rootCauseListNew) { + rootCauseListNewRootCauseToAttach = em.getReference(rootCauseListNewRootCauseToAttach.getClass(), rootCauseListNewRootCauseToAttach.getRootCausePK()); + attachedRootCauseListNew.add(rootCauseListNewRootCauseToAttach); + } + rootCauseListNew = attachedRootCauseListNew; + rootCauseType.setRootCauseList(rootCauseListNew); + rootCauseType = em.merge(rootCauseType); + for (RootCause rootCauseListNewRootCause : rootCauseListNew) { + if (!rootCauseListOld.contains(rootCauseListNewRootCause)) { + RootCauseType oldRootCauseTypeOfRootCauseListNewRootCause = rootCauseListNewRootCause.getRootCauseType(); + rootCauseListNewRootCause.setRootCauseType(rootCauseType); + rootCauseListNewRootCause = em.merge(rootCauseListNewRootCause); + if (oldRootCauseTypeOfRootCauseListNewRootCause != null && !oldRootCauseTypeOfRootCauseListNewRootCause.equals(rootCauseType)) { + oldRootCauseTypeOfRootCauseListNewRootCause.getRootCauseList().remove(rootCauseListNewRootCause); + oldRootCauseTypeOfRootCauseListNewRootCause = em.merge(oldRootCauseTypeOfRootCauseListNewRootCause); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = rootCauseType.getId(); + if (findRootCauseType(id) == null) { + throw new NonexistentEntityException("The rootCauseType with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + RootCauseType rootCauseType; + try { + rootCauseType = em.getReference(RootCauseType.class, id); + rootCauseType.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The rootCauseType with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List rootCauseListOrphanCheck = rootCauseType.getRootCauseList(); + for (RootCause rootCauseListOrphanCheckRootCause : rootCauseListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This RootCauseType (" + rootCauseType + ") cannot be destroyed since the RootCause " + rootCauseListOrphanCheckRootCause + " in its rootCauseList field has a non-nullable rootCauseType field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(rootCauseType); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findRootCauseTypeEntities() { + return findRootCauseTypeEntities(true, -1, -1); + } + + public List findRootCauseTypeEntities(int maxResults, int firstResult) { + return findRootCauseTypeEntities(false, maxResults, firstResult); + } + + private List findRootCauseTypeEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(RootCauseType.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public RootCauseType findRootCauseType(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(RootCauseType.class, id); + } + finally { + em.close(); + } + } + + public int getRootCauseTypeCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(RootCauseType.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/SpecLevelJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/SpecLevelJpaController.java index 2ba104bb..11ac0b54 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/SpecLevelJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/SpecLevelJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.RequirementSpec; -import com.validation.manager.core.db.SpecLevel; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class SpecLevelJpaController implements Serializable { - - public SpecLevelJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(SpecLevel specLevel) { - if (specLevel.getRequirementSpecList() == null) { - specLevel.setRequirementSpecList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedRequirementSpecList = new ArrayList(); - for (RequirementSpec requirementSpecListRequirementSpecToAttach : specLevel.getRequirementSpecList()) { - requirementSpecListRequirementSpecToAttach = em.getReference(requirementSpecListRequirementSpecToAttach.getClass(), requirementSpecListRequirementSpecToAttach.getRequirementSpecPK()); - attachedRequirementSpecList.add(requirementSpecListRequirementSpecToAttach); - } - specLevel.setRequirementSpecList(attachedRequirementSpecList); - em.persist(specLevel); - for (RequirementSpec requirementSpecListRequirementSpec : specLevel.getRequirementSpecList()) { - SpecLevel oldSpecLevelOfRequirementSpecListRequirementSpec = requirementSpecListRequirementSpec.getSpecLevel(); - requirementSpecListRequirementSpec.setSpecLevel(specLevel); - requirementSpecListRequirementSpec = em.merge(requirementSpecListRequirementSpec); - if (oldSpecLevelOfRequirementSpecListRequirementSpec != null) { - oldSpecLevelOfRequirementSpecListRequirementSpec.getRequirementSpecList().remove(requirementSpecListRequirementSpec); - oldSpecLevelOfRequirementSpecListRequirementSpec = em.merge(oldSpecLevelOfRequirementSpecListRequirementSpec); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(SpecLevel specLevel) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - SpecLevel persistentSpecLevel = em.find(SpecLevel.class, specLevel.getId()); - List requirementSpecListOld = persistentSpecLevel.getRequirementSpecList(); - List requirementSpecListNew = specLevel.getRequirementSpecList(); - List illegalOrphanMessages = null; - for (RequirementSpec requirementSpecListOldRequirementSpec : requirementSpecListOld) { - if (!requirementSpecListNew.contains(requirementSpecListOldRequirementSpec)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RequirementSpec " + requirementSpecListOldRequirementSpec + " since its specLevel field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedRequirementSpecListNew = new ArrayList(); - for (RequirementSpec requirementSpecListNewRequirementSpecToAttach : requirementSpecListNew) { - requirementSpecListNewRequirementSpecToAttach = em.getReference(requirementSpecListNewRequirementSpecToAttach.getClass(), requirementSpecListNewRequirementSpecToAttach.getRequirementSpecPK()); - attachedRequirementSpecListNew.add(requirementSpecListNewRequirementSpecToAttach); - } - requirementSpecListNew = attachedRequirementSpecListNew; - specLevel.setRequirementSpecList(requirementSpecListNew); - specLevel = em.merge(specLevel); - for (RequirementSpec requirementSpecListNewRequirementSpec : requirementSpecListNew) { - if (!requirementSpecListOld.contains(requirementSpecListNewRequirementSpec)) { - SpecLevel oldSpecLevelOfRequirementSpecListNewRequirementSpec = requirementSpecListNewRequirementSpec.getSpecLevel(); - requirementSpecListNewRequirementSpec.setSpecLevel(specLevel); - requirementSpecListNewRequirementSpec = em.merge(requirementSpecListNewRequirementSpec); - if (oldSpecLevelOfRequirementSpecListNewRequirementSpec != null && !oldSpecLevelOfRequirementSpecListNewRequirementSpec.equals(specLevel)) { - oldSpecLevelOfRequirementSpecListNewRequirementSpec.getRequirementSpecList().remove(requirementSpecListNewRequirementSpec); - oldSpecLevelOfRequirementSpecListNewRequirementSpec = em.merge(oldSpecLevelOfRequirementSpecListNewRequirementSpec); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = specLevel.getId(); - if (findSpecLevel(id) == null) { - throw new NonexistentEntityException("The specLevel with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - SpecLevel specLevel; - try { - specLevel = em.getReference(SpecLevel.class, id); - specLevel.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The specLevel with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List requirementSpecListOrphanCheck = specLevel.getRequirementSpecList(); - for (RequirementSpec requirementSpecListOrphanCheckRequirementSpec : requirementSpecListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This SpecLevel (" + specLevel + ") cannot be destroyed since the RequirementSpec " + requirementSpecListOrphanCheckRequirementSpec + " in its requirementSpecList field has a non-nullable specLevel field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(specLevel); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findSpecLevelEntities() { - return findSpecLevelEntities(true, -1, -1); - } - - public List findSpecLevelEntities(int maxResults, int firstResult) { - return findSpecLevelEntities(false, maxResults, firstResult); - } - - private List findSpecLevelEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(SpecLevel.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public SpecLevel findSpecLevel(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(SpecLevel.class, id); - } - finally { - em.close(); - } - } - - public int getSpecLevelCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(SpecLevel.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.RequirementSpec; +import com.validation.manager.core.db.SpecLevel; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class SpecLevelJpaController implements Serializable { + + public SpecLevelJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(SpecLevel specLevel) { + if (specLevel.getRequirementSpecList() == null) { + specLevel.setRequirementSpecList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedRequirementSpecList = new ArrayList<>(); + for (RequirementSpec requirementSpecListRequirementSpecToAttach : specLevel.getRequirementSpecList()) { + requirementSpecListRequirementSpecToAttach = em.getReference(requirementSpecListRequirementSpecToAttach.getClass(), requirementSpecListRequirementSpecToAttach.getRequirementSpecPK()); + attachedRequirementSpecList.add(requirementSpecListRequirementSpecToAttach); + } + specLevel.setRequirementSpecList(attachedRequirementSpecList); + em.persist(specLevel); + for (RequirementSpec requirementSpecListRequirementSpec : specLevel.getRequirementSpecList()) { + SpecLevel oldSpecLevelOfRequirementSpecListRequirementSpec = requirementSpecListRequirementSpec.getSpecLevel(); + requirementSpecListRequirementSpec.setSpecLevel(specLevel); + requirementSpecListRequirementSpec = em.merge(requirementSpecListRequirementSpec); + if (oldSpecLevelOfRequirementSpecListRequirementSpec != null) { + oldSpecLevelOfRequirementSpecListRequirementSpec.getRequirementSpecList().remove(requirementSpecListRequirementSpec); + oldSpecLevelOfRequirementSpecListRequirementSpec = em.merge(oldSpecLevelOfRequirementSpecListRequirementSpec); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(SpecLevel specLevel) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + SpecLevel persistentSpecLevel = em.find(SpecLevel.class, specLevel.getId()); + List requirementSpecListOld = persistentSpecLevel.getRequirementSpecList(); + List requirementSpecListNew = specLevel.getRequirementSpecList(); + List illegalOrphanMessages = null; + for (RequirementSpec requirementSpecListOldRequirementSpec : requirementSpecListOld) { + if (!requirementSpecListNew.contains(requirementSpecListOldRequirementSpec)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RequirementSpec " + requirementSpecListOldRequirementSpec + " since its specLevel field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedRequirementSpecListNew = new ArrayList<>(); + for (RequirementSpec requirementSpecListNewRequirementSpecToAttach : requirementSpecListNew) { + requirementSpecListNewRequirementSpecToAttach = em.getReference(requirementSpecListNewRequirementSpecToAttach.getClass(), requirementSpecListNewRequirementSpecToAttach.getRequirementSpecPK()); + attachedRequirementSpecListNew.add(requirementSpecListNewRequirementSpecToAttach); + } + requirementSpecListNew = attachedRequirementSpecListNew; + specLevel.setRequirementSpecList(requirementSpecListNew); + specLevel = em.merge(specLevel); + for (RequirementSpec requirementSpecListNewRequirementSpec : requirementSpecListNew) { + if (!requirementSpecListOld.contains(requirementSpecListNewRequirementSpec)) { + SpecLevel oldSpecLevelOfRequirementSpecListNewRequirementSpec = requirementSpecListNewRequirementSpec.getSpecLevel(); + requirementSpecListNewRequirementSpec.setSpecLevel(specLevel); + requirementSpecListNewRequirementSpec = em.merge(requirementSpecListNewRequirementSpec); + if (oldSpecLevelOfRequirementSpecListNewRequirementSpec != null && !oldSpecLevelOfRequirementSpecListNewRequirementSpec.equals(specLevel)) { + oldSpecLevelOfRequirementSpecListNewRequirementSpec.getRequirementSpecList().remove(requirementSpecListNewRequirementSpec); + oldSpecLevelOfRequirementSpecListNewRequirementSpec = em.merge(oldSpecLevelOfRequirementSpecListNewRequirementSpec); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = specLevel.getId(); + if (findSpecLevel(id) == null) { + throw new NonexistentEntityException("The specLevel with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + SpecLevel specLevel; + try { + specLevel = em.getReference(SpecLevel.class, id); + specLevel.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The specLevel with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List requirementSpecListOrphanCheck = specLevel.getRequirementSpecList(); + for (RequirementSpec requirementSpecListOrphanCheckRequirementSpec : requirementSpecListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This SpecLevel (" + specLevel + ") cannot be destroyed since the RequirementSpec " + requirementSpecListOrphanCheckRequirementSpec + " in its requirementSpecList field has a non-nullable specLevel field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(specLevel); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findSpecLevelEntities() { + return findSpecLevelEntities(true, -1, -1); + } + + public List findSpecLevelEntities(int maxResults, int firstResult) { + return findSpecLevelEntities(false, maxResults, firstResult); + } + + private List findSpecLevelEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(SpecLevel.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public SpecLevel findSpecLevel(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(SpecLevel.class, id); + } + finally { + em.close(); + } + } + + public int getSpecLevelCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(SpecLevel.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/StepJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/StepJpaController.java index 251fc57e..9dac0b91 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/StepJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/StepJpaController.java @@ -13,345 +13,345 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.Requirement; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.Step; -import com.validation.manager.core.db.StepPK; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class StepJpaController implements Serializable { - - public StepJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(Step step) throws PreexistingEntityException, Exception { - if (step.getStepPK() == null) { - step.setStepPK(new StepPK()); - } - if (step.getRequirementList() == null) { - step.setRequirementList(new ArrayList()); - } - if (step.getExecutionStepList() == null) { - step.setExecutionStepList(new ArrayList()); - } - if (step.getHistoryList() == null) { - step.setHistoryList(new ArrayList()); - } - step.getStepPK().setTestCaseId(step.getTestCase().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - TestCase testCase = step.getTestCase(); - if (testCase != null) { - testCase = em.getReference(testCase.getClass(), testCase.getId()); - step.setTestCase(testCase); - } - List attachedRequirementList = new ArrayList(); - for (Requirement requirementListRequirementToAttach : step.getRequirementList()) { - requirementListRequirementToAttach = em.getReference(requirementListRequirementToAttach.getClass(), requirementListRequirementToAttach.getId()); - attachedRequirementList.add(requirementListRequirementToAttach); - } - step.setRequirementList(attachedRequirementList); - List attachedExecutionStepList = new ArrayList(); - for (ExecutionStep executionStepListExecutionStepToAttach : step.getExecutionStepList()) { - executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepList.add(executionStepListExecutionStepToAttach); - } - step.setExecutionStepList(attachedExecutionStepList); - List attachedHistoryList = new ArrayList(); - for (History historyListHistoryToAttach : step.getHistoryList()) { - historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); - attachedHistoryList.add(historyListHistoryToAttach); - } - step.setHistoryList(attachedHistoryList); - em.persist(step); - if (testCase != null) { - testCase.getStepList().add(step); - testCase = em.merge(testCase); - } - for (Requirement requirementListRequirement : step.getRequirementList()) { - requirementListRequirement.getStepList().add(step); - requirementListRequirement = em.merge(requirementListRequirement); - } - for (ExecutionStep executionStepListExecutionStep : step.getExecutionStepList()) { - Step oldStepOfExecutionStepListExecutionStep = executionStepListExecutionStep.getStep(); - executionStepListExecutionStep.setStep(step); - executionStepListExecutionStep = em.merge(executionStepListExecutionStep); - if (oldStepOfExecutionStepListExecutionStep != null) { - oldStepOfExecutionStepListExecutionStep.getExecutionStepList().remove(executionStepListExecutionStep); - oldStepOfExecutionStepListExecutionStep = em.merge(oldStepOfExecutionStepListExecutionStep); - } - } - for (History historyListHistory : step.getHistoryList()) { - Step oldStepOfHistoryListHistory = historyListHistory.getStep(); - historyListHistory.setStep(step); - historyListHistory = em.merge(historyListHistory); - if (oldStepOfHistoryListHistory != null) { - oldStepOfHistoryListHistory.getHistoryList().remove(historyListHistory); - oldStepOfHistoryListHistory = em.merge(oldStepOfHistoryListHistory); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findStep(step.getStepPK()) != null) { - throw new PreexistingEntityException("Step " + step + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(Step step) throws IllegalOrphanException, NonexistentEntityException, Exception { - step.getStepPK().setTestCaseId(step.getTestCase().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Step persistentStep = em.find(Step.class, step.getStepPK()); - TestCase testCaseOld = persistentStep.getTestCase(); - TestCase testCaseNew = step.getTestCase(); - List requirementListOld = persistentStep.getRequirementList(); - List requirementListNew = step.getRequirementList(); - List executionStepListOld = persistentStep.getExecutionStepList(); - List executionStepListNew = step.getExecutionStepList(); - List historyListOld = persistentStep.getHistoryList(); - List historyListNew = step.getHistoryList(); - List illegalOrphanMessages = null; - for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { - if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExecutionStep " + executionStepListOldExecutionStep + " since its step field is not nullable."); - } - } - for (History historyListOldHistory : historyListOld) { - if (!historyListNew.contains(historyListOldHistory)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain History " + historyListOldHistory + " since its step field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (testCaseNew != null) { - testCaseNew = em.getReference(testCaseNew.getClass(), testCaseNew.getId()); - step.setTestCase(testCaseNew); - } - List attachedRequirementListNew = new ArrayList(); - for (Requirement requirementListNewRequirementToAttach : requirementListNew) { - requirementListNewRequirementToAttach = em.getReference(requirementListNewRequirementToAttach.getClass(), requirementListNewRequirementToAttach.getId()); - attachedRequirementListNew.add(requirementListNewRequirementToAttach); - } - requirementListNew = attachedRequirementListNew; - step.setRequirementList(requirementListNew); - List attachedExecutionStepListNew = new ArrayList(); - for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { - executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); - } - executionStepListNew = attachedExecutionStepListNew; - step.setExecutionStepList(executionStepListNew); - List attachedHistoryListNew = new ArrayList(); - for (History historyListNewHistoryToAttach : historyListNew) { - historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); - attachedHistoryListNew.add(historyListNewHistoryToAttach); - } - historyListNew = attachedHistoryListNew; - step.setHistoryList(historyListNew); - step = em.merge(step); - if (testCaseOld != null && !testCaseOld.equals(testCaseNew)) { - testCaseOld.getStepList().remove(step); - testCaseOld = em.merge(testCaseOld); - } - if (testCaseNew != null && !testCaseNew.equals(testCaseOld)) { - testCaseNew.getStepList().add(step); - testCaseNew = em.merge(testCaseNew); - } - for (Requirement requirementListOldRequirement : requirementListOld) { - if (!requirementListNew.contains(requirementListOldRequirement)) { - requirementListOldRequirement.getStepList().remove(step); - requirementListOldRequirement = em.merge(requirementListOldRequirement); - } - } - for (Requirement requirementListNewRequirement : requirementListNew) { - if (!requirementListOld.contains(requirementListNewRequirement)) { - requirementListNewRequirement.getStepList().add(step); - requirementListNewRequirement = em.merge(requirementListNewRequirement); - } - } - for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { - if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { - Step oldStepOfExecutionStepListNewExecutionStep = executionStepListNewExecutionStep.getStep(); - executionStepListNewExecutionStep.setStep(step); - executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); - if (oldStepOfExecutionStepListNewExecutionStep != null && !oldStepOfExecutionStepListNewExecutionStep.equals(step)) { - oldStepOfExecutionStepListNewExecutionStep.getExecutionStepList().remove(executionStepListNewExecutionStep); - oldStepOfExecutionStepListNewExecutionStep = em.merge(oldStepOfExecutionStepListNewExecutionStep); - } - } - } - for (History historyListNewHistory : historyListNew) { - if (!historyListOld.contains(historyListNewHistory)) { - Step oldStepOfHistoryListNewHistory = historyListNewHistory.getStep(); - historyListNewHistory.setStep(step); - historyListNewHistory = em.merge(historyListNewHistory); - if (oldStepOfHistoryListNewHistory != null && !oldStepOfHistoryListNewHistory.equals(step)) { - oldStepOfHistoryListNewHistory.getHistoryList().remove(historyListNewHistory); - oldStepOfHistoryListNewHistory = em.merge(oldStepOfHistoryListNewHistory); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - StepPK id = step.getStepPK(); - if (findStep(id) == null) { - throw new NonexistentEntityException("The step with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(StepPK id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - Step step; - try { - step = em.getReference(Step.class, id); - step.getStepPK(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The step with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List executionStepListOrphanCheck = step.getExecutionStepList(); - for (ExecutionStep executionStepListOrphanCheckExecutionStep : executionStepListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Step (" + step + ") cannot be destroyed since the ExecutionStep " + executionStepListOrphanCheckExecutionStep + " in its executionStepList field has a non-nullable step field."); - } - List historyListOrphanCheck = step.getHistoryList(); - for (History historyListOrphanCheckHistory : historyListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This Step (" + step + ") cannot be destroyed since the History " + historyListOrphanCheckHistory + " in its historyList field has a non-nullable step field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - TestCase testCase = step.getTestCase(); - if (testCase != null) { - testCase.getStepList().remove(step); - testCase = em.merge(testCase); - } - List requirementList = step.getRequirementList(); - for (Requirement requirementListRequirement : requirementList) { - requirementListRequirement.getStepList().remove(step); - requirementListRequirement = em.merge(requirementListRequirement); - } - em.remove(step); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findStepEntities() { - return findStepEntities(true, -1, -1); - } - - public List findStepEntities(int maxResults, int firstResult) { - return findStepEntities(false, maxResults, firstResult); - } - - private List findStepEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(Step.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public Step findStep(StepPK id) { - EntityManager em = getEntityManager(); - try { - return em.find(Step.class, id); - } - finally { - em.close(); - } - } - - public int getStepCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(Step.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.Requirement; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.Step; +import com.validation.manager.core.db.StepPK; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class StepJpaController implements Serializable { + + public StepJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(Step step) throws PreexistingEntityException, Exception { + if (step.getStepPK() == null) { + step.setStepPK(new StepPK()); + } + if (step.getRequirementList() == null) { + step.setRequirementList(new ArrayList<>()); + } + if (step.getExecutionStepList() == null) { + step.setExecutionStepList(new ArrayList<>()); + } + if (step.getHistoryList() == null) { + step.setHistoryList(new ArrayList<>()); + } + step.getStepPK().setTestCaseId(step.getTestCase().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + TestCase testCase = step.getTestCase(); + if (testCase != null) { + testCase = em.getReference(testCase.getClass(), testCase.getId()); + step.setTestCase(testCase); + } + List attachedRequirementList = new ArrayList<>(); + for (Requirement requirementListRequirementToAttach : step.getRequirementList()) { + requirementListRequirementToAttach = em.getReference(requirementListRequirementToAttach.getClass(), requirementListRequirementToAttach.getId()); + attachedRequirementList.add(requirementListRequirementToAttach); + } + step.setRequirementList(attachedRequirementList); + List attachedExecutionStepList = new ArrayList<>(); + for (ExecutionStep executionStepListExecutionStepToAttach : step.getExecutionStepList()) { + executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepList.add(executionStepListExecutionStepToAttach); + } + step.setExecutionStepList(attachedExecutionStepList); + List attachedHistoryList = new ArrayList<>(); + for (History historyListHistoryToAttach : step.getHistoryList()) { + historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); + attachedHistoryList.add(historyListHistoryToAttach); + } + step.setHistoryList(attachedHistoryList); + em.persist(step); + if (testCase != null) { + testCase.getStepList().add(step); + testCase = em.merge(testCase); + } + for (Requirement requirementListRequirement : step.getRequirementList()) { + requirementListRequirement.getStepList().add(step); + requirementListRequirement = em.merge(requirementListRequirement); + } + for (ExecutionStep executionStepListExecutionStep : step.getExecutionStepList()) { + Step oldStepOfExecutionStepListExecutionStep = executionStepListExecutionStep.getStep(); + executionStepListExecutionStep.setStep(step); + executionStepListExecutionStep = em.merge(executionStepListExecutionStep); + if (oldStepOfExecutionStepListExecutionStep != null) { + oldStepOfExecutionStepListExecutionStep.getExecutionStepList().remove(executionStepListExecutionStep); + oldStepOfExecutionStepListExecutionStep = em.merge(oldStepOfExecutionStepListExecutionStep); + } + } + for (History historyListHistory : step.getHistoryList()) { + Step oldStepOfHistoryListHistory = historyListHistory.getStep(); + historyListHistory.setStep(step); + historyListHistory = em.merge(historyListHistory); + if (oldStepOfHistoryListHistory != null) { + oldStepOfHistoryListHistory.getHistoryList().remove(historyListHistory); + oldStepOfHistoryListHistory = em.merge(oldStepOfHistoryListHistory); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findStep(step.getStepPK()) != null) { + throw new PreexistingEntityException("Step " + step + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(Step step) throws IllegalOrphanException, NonexistentEntityException, Exception { + step.getStepPK().setTestCaseId(step.getTestCase().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Step persistentStep = em.find(Step.class, step.getStepPK()); + TestCase testCaseOld = persistentStep.getTestCase(); + TestCase testCaseNew = step.getTestCase(); + List requirementListOld = persistentStep.getRequirementList(); + List requirementListNew = step.getRequirementList(); + List executionStepListOld = persistentStep.getExecutionStepList(); + List executionStepListNew = step.getExecutionStepList(); + List historyListOld = persistentStep.getHistoryList(); + List historyListNew = step.getHistoryList(); + List illegalOrphanMessages = null; + for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { + if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExecutionStep " + executionStepListOldExecutionStep + " since its step field is not nullable."); + } + } + for (History historyListOldHistory : historyListOld) { + if (!historyListNew.contains(historyListOldHistory)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain History " + historyListOldHistory + " since its step field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (testCaseNew != null) { + testCaseNew = em.getReference(testCaseNew.getClass(), testCaseNew.getId()); + step.setTestCase(testCaseNew); + } + List attachedRequirementListNew = new ArrayList<>(); + for (Requirement requirementListNewRequirementToAttach : requirementListNew) { + requirementListNewRequirementToAttach = em.getReference(requirementListNewRequirementToAttach.getClass(), requirementListNewRequirementToAttach.getId()); + attachedRequirementListNew.add(requirementListNewRequirementToAttach); + } + requirementListNew = attachedRequirementListNew; + step.setRequirementList(requirementListNew); + List attachedExecutionStepListNew = new ArrayList<>(); + for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { + executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); + } + executionStepListNew = attachedExecutionStepListNew; + step.setExecutionStepList(executionStepListNew); + List attachedHistoryListNew = new ArrayList<>(); + for (History historyListNewHistoryToAttach : historyListNew) { + historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); + attachedHistoryListNew.add(historyListNewHistoryToAttach); + } + historyListNew = attachedHistoryListNew; + step.setHistoryList(historyListNew); + step = em.merge(step); + if (testCaseOld != null && !testCaseOld.equals(testCaseNew)) { + testCaseOld.getStepList().remove(step); + testCaseOld = em.merge(testCaseOld); + } + if (testCaseNew != null && !testCaseNew.equals(testCaseOld)) { + testCaseNew.getStepList().add(step); + testCaseNew = em.merge(testCaseNew); + } + for (Requirement requirementListOldRequirement : requirementListOld) { + if (!requirementListNew.contains(requirementListOldRequirement)) { + requirementListOldRequirement.getStepList().remove(step); + requirementListOldRequirement = em.merge(requirementListOldRequirement); + } + } + for (Requirement requirementListNewRequirement : requirementListNew) { + if (!requirementListOld.contains(requirementListNewRequirement)) { + requirementListNewRequirement.getStepList().add(step); + requirementListNewRequirement = em.merge(requirementListNewRequirement); + } + } + for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { + if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { + Step oldStepOfExecutionStepListNewExecutionStep = executionStepListNewExecutionStep.getStep(); + executionStepListNewExecutionStep.setStep(step); + executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); + if (oldStepOfExecutionStepListNewExecutionStep != null && !oldStepOfExecutionStepListNewExecutionStep.equals(step)) { + oldStepOfExecutionStepListNewExecutionStep.getExecutionStepList().remove(executionStepListNewExecutionStep); + oldStepOfExecutionStepListNewExecutionStep = em.merge(oldStepOfExecutionStepListNewExecutionStep); + } + } + } + for (History historyListNewHistory : historyListNew) { + if (!historyListOld.contains(historyListNewHistory)) { + Step oldStepOfHistoryListNewHistory = historyListNewHistory.getStep(); + historyListNewHistory.setStep(step); + historyListNewHistory = em.merge(historyListNewHistory); + if (oldStepOfHistoryListNewHistory != null && !oldStepOfHistoryListNewHistory.equals(step)) { + oldStepOfHistoryListNewHistory.getHistoryList().remove(historyListNewHistory); + oldStepOfHistoryListNewHistory = em.merge(oldStepOfHistoryListNewHistory); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + StepPK id = step.getStepPK(); + if (findStep(id) == null) { + throw new NonexistentEntityException("The step with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(StepPK id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + Step step; + try { + step = em.getReference(Step.class, id); + step.getStepPK(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The step with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List executionStepListOrphanCheck = step.getExecutionStepList(); + for (ExecutionStep executionStepListOrphanCheckExecutionStep : executionStepListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Step (" + step + ") cannot be destroyed since the ExecutionStep " + executionStepListOrphanCheckExecutionStep + " in its executionStepList field has a non-nullable step field."); + } + List historyListOrphanCheck = step.getHistoryList(); + for (History historyListOrphanCheckHistory : historyListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This Step (" + step + ") cannot be destroyed since the History " + historyListOrphanCheckHistory + " in its historyList field has a non-nullable step field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + TestCase testCase = step.getTestCase(); + if (testCase != null) { + testCase.getStepList().remove(step); + testCase = em.merge(testCase); + } + List requirementList = step.getRequirementList(); + for (Requirement requirementListRequirement : requirementList) { + requirementListRequirement.getStepList().remove(step); + requirementListRequirement = em.merge(requirementListRequirement); + } + em.remove(step); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findStepEntities() { + return findStepEntities(true, -1, -1); + } + + public List findStepEntities(int maxResults, int firstResult) { + return findStepEntities(false, maxResults, firstResult); + } + + private List findStepEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(Step.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public Step findStep(StepPK id) { + EntityManager em = getEntityManager(); + try { + return em.find(Step.class, id); + } + finally { + em.close(); + } + } + + public int getStepCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(Step.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestCaseExecutionJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestCaseExecutionJpaController.java index e7156e5e..dda77abd 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestCaseExecutionJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestCaseExecutionJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.TestCaseExecution; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class TestCaseExecutionJpaController implements Serializable { - - public TestCaseExecutionJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(TestCaseExecution testCaseExecution) { - if (testCaseExecution.getExecutionStepList() == null) { - testCaseExecution.setExecutionStepList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedExecutionStepList = new ArrayList(); - for (ExecutionStep executionStepListExecutionStepToAttach : testCaseExecution.getExecutionStepList()) { - executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepList.add(executionStepListExecutionStepToAttach); - } - testCaseExecution.setExecutionStepList(attachedExecutionStepList); - em.persist(testCaseExecution); - for (ExecutionStep executionStepListExecutionStep : testCaseExecution.getExecutionStepList()) { - TestCaseExecution oldTestCaseExecutionOfExecutionStepListExecutionStep = executionStepListExecutionStep.getTestCaseExecution(); - executionStepListExecutionStep.setTestCaseExecution(testCaseExecution); - executionStepListExecutionStep = em.merge(executionStepListExecutionStep); - if (oldTestCaseExecutionOfExecutionStepListExecutionStep != null) { - oldTestCaseExecutionOfExecutionStepListExecutionStep.getExecutionStepList().remove(executionStepListExecutionStep); - oldTestCaseExecutionOfExecutionStepListExecutionStep = em.merge(oldTestCaseExecutionOfExecutionStepListExecutionStep); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(TestCaseExecution testCaseExecution) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - TestCaseExecution persistentTestCaseExecution = em.find(TestCaseExecution.class, testCaseExecution.getId()); - List executionStepListOld = persistentTestCaseExecution.getExecutionStepList(); - List executionStepListNew = testCaseExecution.getExecutionStepList(); - List illegalOrphanMessages = null; - for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { - if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExecutionStep " + executionStepListOldExecutionStep + " since its testCaseExecution field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedExecutionStepListNew = new ArrayList(); - for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { - executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); - } - executionStepListNew = attachedExecutionStepListNew; - testCaseExecution.setExecutionStepList(executionStepListNew); - testCaseExecution = em.merge(testCaseExecution); - for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { - if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { - TestCaseExecution oldTestCaseExecutionOfExecutionStepListNewExecutionStep = executionStepListNewExecutionStep.getTestCaseExecution(); - executionStepListNewExecutionStep.setTestCaseExecution(testCaseExecution); - executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); - if (oldTestCaseExecutionOfExecutionStepListNewExecutionStep != null && !oldTestCaseExecutionOfExecutionStepListNewExecutionStep.equals(testCaseExecution)) { - oldTestCaseExecutionOfExecutionStepListNewExecutionStep.getExecutionStepList().remove(executionStepListNewExecutionStep); - oldTestCaseExecutionOfExecutionStepListNewExecutionStep = em.merge(oldTestCaseExecutionOfExecutionStepListNewExecutionStep); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = testCaseExecution.getId(); - if (findTestCaseExecution(id) == null) { - throw new NonexistentEntityException("The testCaseExecution with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - TestCaseExecution testCaseExecution; - try { - testCaseExecution = em.getReference(TestCaseExecution.class, id); - testCaseExecution.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The testCaseExecution with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List executionStepListOrphanCheck = testCaseExecution.getExecutionStepList(); - for (ExecutionStep executionStepListOrphanCheckExecutionStep : executionStepListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This TestCaseExecution (" + testCaseExecution + ") cannot be destroyed since the ExecutionStep " + executionStepListOrphanCheckExecutionStep + " in its executionStepList field has a non-nullable testCaseExecution field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(testCaseExecution); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findTestCaseExecutionEntities() { - return findTestCaseExecutionEntities(true, -1, -1); - } - - public List findTestCaseExecutionEntities(int maxResults, int firstResult) { - return findTestCaseExecutionEntities(false, maxResults, firstResult); - } - - private List findTestCaseExecutionEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(TestCaseExecution.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public TestCaseExecution findTestCaseExecution(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(TestCaseExecution.class, id); - } - finally { - em.close(); - } - } - - public int getTestCaseExecutionCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(TestCaseExecution.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.TestCaseExecution; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class TestCaseExecutionJpaController implements Serializable { + + public TestCaseExecutionJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(TestCaseExecution testCaseExecution) { + if (testCaseExecution.getExecutionStepList() == null) { + testCaseExecution.setExecutionStepList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedExecutionStepList = new ArrayList<>(); + for (ExecutionStep executionStepListExecutionStepToAttach : testCaseExecution.getExecutionStepList()) { + executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepList.add(executionStepListExecutionStepToAttach); + } + testCaseExecution.setExecutionStepList(attachedExecutionStepList); + em.persist(testCaseExecution); + for (ExecutionStep executionStepListExecutionStep : testCaseExecution.getExecutionStepList()) { + TestCaseExecution oldTestCaseExecutionOfExecutionStepListExecutionStep = executionStepListExecutionStep.getTestCaseExecution(); + executionStepListExecutionStep.setTestCaseExecution(testCaseExecution); + executionStepListExecutionStep = em.merge(executionStepListExecutionStep); + if (oldTestCaseExecutionOfExecutionStepListExecutionStep != null) { + oldTestCaseExecutionOfExecutionStepListExecutionStep.getExecutionStepList().remove(executionStepListExecutionStep); + oldTestCaseExecutionOfExecutionStepListExecutionStep = em.merge(oldTestCaseExecutionOfExecutionStepListExecutionStep); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(TestCaseExecution testCaseExecution) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + TestCaseExecution persistentTestCaseExecution = em.find(TestCaseExecution.class, testCaseExecution.getId()); + List executionStepListOld = persistentTestCaseExecution.getExecutionStepList(); + List executionStepListNew = testCaseExecution.getExecutionStepList(); + List illegalOrphanMessages = null; + for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { + if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExecutionStep " + executionStepListOldExecutionStep + " since its testCaseExecution field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedExecutionStepListNew = new ArrayList<>(); + for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { + executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); + } + executionStepListNew = attachedExecutionStepListNew; + testCaseExecution.setExecutionStepList(executionStepListNew); + testCaseExecution = em.merge(testCaseExecution); + for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { + if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { + TestCaseExecution oldTestCaseExecutionOfExecutionStepListNewExecutionStep = executionStepListNewExecutionStep.getTestCaseExecution(); + executionStepListNewExecutionStep.setTestCaseExecution(testCaseExecution); + executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); + if (oldTestCaseExecutionOfExecutionStepListNewExecutionStep != null && !oldTestCaseExecutionOfExecutionStepListNewExecutionStep.equals(testCaseExecution)) { + oldTestCaseExecutionOfExecutionStepListNewExecutionStep.getExecutionStepList().remove(executionStepListNewExecutionStep); + oldTestCaseExecutionOfExecutionStepListNewExecutionStep = em.merge(oldTestCaseExecutionOfExecutionStepListNewExecutionStep); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = testCaseExecution.getId(); + if (findTestCaseExecution(id) == null) { + throw new NonexistentEntityException("The testCaseExecution with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + TestCaseExecution testCaseExecution; + try { + testCaseExecution = em.getReference(TestCaseExecution.class, id); + testCaseExecution.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The testCaseExecution with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List executionStepListOrphanCheck = testCaseExecution.getExecutionStepList(); + for (ExecutionStep executionStepListOrphanCheckExecutionStep : executionStepListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This TestCaseExecution (" + testCaseExecution + ") cannot be destroyed since the ExecutionStep " + executionStepListOrphanCheckExecutionStep + " in its executionStepList field has a non-nullable testCaseExecution field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(testCaseExecution); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findTestCaseExecutionEntities() { + return findTestCaseExecutionEntities(true, -1, -1); + } + + public List findTestCaseExecutionEntities(int maxResults, int firstResult) { + return findTestCaseExecutionEntities(false, maxResults, firstResult); + } + + private List findTestCaseExecutionEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(TestCaseExecution.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public TestCaseExecution findTestCaseExecution(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(TestCaseExecution.class, id); + } + finally { + em.close(); + } + } + + public int getTestCaseExecutionCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(TestCaseExecution.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestCaseJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestCaseJpaController.java index 47b67f17..aeeee3df 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestCaseJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestCaseJpaController.java @@ -13,303 +13,303 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.TestPlan; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.RiskControlHasTestCase; -import com.validation.manager.core.db.Step; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class TestCaseJpaController implements Serializable { - - public TestCaseJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(TestCase testCase) { - if (testCase.getTestPlanList() == null) { - testCase.setTestPlanList(new ArrayList()); - } - if (testCase.getRiskControlHasTestCaseList() == null) { - testCase.setRiskControlHasTestCaseList(new ArrayList()); - } - if (testCase.getStepList() == null) { - testCase.setStepList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedTestPlanList = new ArrayList(); - for (TestPlan testPlanListTestPlanToAttach : testCase.getTestPlanList()) { - testPlanListTestPlanToAttach = em.getReference(testPlanListTestPlanToAttach.getClass(), testPlanListTestPlanToAttach.getTestPlanPK()); - attachedTestPlanList.add(testPlanListTestPlanToAttach); - } - testCase.setTestPlanList(attachedTestPlanList); - List attachedRiskControlHasTestCaseList = new ArrayList(); - for (RiskControlHasTestCase riskControlHasTestCaseListRiskControlHasTestCaseToAttach : testCase.getRiskControlHasTestCaseList()) { - riskControlHasTestCaseListRiskControlHasTestCaseToAttach = em.getReference(riskControlHasTestCaseListRiskControlHasTestCaseToAttach.getClass(), riskControlHasTestCaseListRiskControlHasTestCaseToAttach.getRiskControlHasTestCasePK()); - attachedRiskControlHasTestCaseList.add(riskControlHasTestCaseListRiskControlHasTestCaseToAttach); - } - testCase.setRiskControlHasTestCaseList(attachedRiskControlHasTestCaseList); - List attachedStepList = new ArrayList(); - for (Step stepListStepToAttach : testCase.getStepList()) { - stepListStepToAttach = em.getReference(stepListStepToAttach.getClass(), stepListStepToAttach.getStepPK()); - attachedStepList.add(stepListStepToAttach); - } - testCase.setStepList(attachedStepList); - em.persist(testCase); - for (TestPlan testPlanListTestPlan : testCase.getTestPlanList()) { - testPlanListTestPlan.getTestCaseList().add(testCase); - testPlanListTestPlan = em.merge(testPlanListTestPlan); - } - for (RiskControlHasTestCase riskControlHasTestCaseListRiskControlHasTestCase : testCase.getRiskControlHasTestCaseList()) { - TestCase oldTestCaseOfRiskControlHasTestCaseListRiskControlHasTestCase = riskControlHasTestCaseListRiskControlHasTestCase.getTestCase(); - riskControlHasTestCaseListRiskControlHasTestCase.setTestCase(testCase); - riskControlHasTestCaseListRiskControlHasTestCase = em.merge(riskControlHasTestCaseListRiskControlHasTestCase); - if (oldTestCaseOfRiskControlHasTestCaseListRiskControlHasTestCase != null) { - oldTestCaseOfRiskControlHasTestCaseListRiskControlHasTestCase.getRiskControlHasTestCaseList().remove(riskControlHasTestCaseListRiskControlHasTestCase); - oldTestCaseOfRiskControlHasTestCaseListRiskControlHasTestCase = em.merge(oldTestCaseOfRiskControlHasTestCaseListRiskControlHasTestCase); - } - } - for (Step stepListStep : testCase.getStepList()) { - TestCase oldTestCaseOfStepListStep = stepListStep.getTestCase(); - stepListStep.setTestCase(testCase); - stepListStep = em.merge(stepListStep); - if (oldTestCaseOfStepListStep != null) { - oldTestCaseOfStepListStep.getStepList().remove(stepListStep); - oldTestCaseOfStepListStep = em.merge(oldTestCaseOfStepListStep); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(TestCase testCase) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - TestCase persistentTestCase = em.find(TestCase.class, testCase.getId()); - List testPlanListOld = persistentTestCase.getTestPlanList(); - List testPlanListNew = testCase.getTestPlanList(); - List riskControlHasTestCaseListOld = persistentTestCase.getRiskControlHasTestCaseList(); - List riskControlHasTestCaseListNew = testCase.getRiskControlHasTestCaseList(); - List stepListOld = persistentTestCase.getStepList(); - List stepListNew = testCase.getStepList(); - List illegalOrphanMessages = null; - for (RiskControlHasTestCase riskControlHasTestCaseListOldRiskControlHasTestCase : riskControlHasTestCaseListOld) { - if (!riskControlHasTestCaseListNew.contains(riskControlHasTestCaseListOldRiskControlHasTestCase)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain RiskControlHasTestCase " + riskControlHasTestCaseListOldRiskControlHasTestCase + " since its testCase field is not nullable."); - } - } - for (Step stepListOldStep : stepListOld) { - if (!stepListNew.contains(stepListOldStep)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain Step " + stepListOldStep + " since its testCase field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedTestPlanListNew = new ArrayList(); - for (TestPlan testPlanListNewTestPlanToAttach : testPlanListNew) { - testPlanListNewTestPlanToAttach = em.getReference(testPlanListNewTestPlanToAttach.getClass(), testPlanListNewTestPlanToAttach.getTestPlanPK()); - attachedTestPlanListNew.add(testPlanListNewTestPlanToAttach); - } - testPlanListNew = attachedTestPlanListNew; - testCase.setTestPlanList(testPlanListNew); - List attachedRiskControlHasTestCaseListNew = new ArrayList(); - for (RiskControlHasTestCase riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach : riskControlHasTestCaseListNew) { - riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach = em.getReference(riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach.getClass(), riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach.getRiskControlHasTestCasePK()); - attachedRiskControlHasTestCaseListNew.add(riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach); - } - riskControlHasTestCaseListNew = attachedRiskControlHasTestCaseListNew; - testCase.setRiskControlHasTestCaseList(riskControlHasTestCaseListNew); - List attachedStepListNew = new ArrayList(); - for (Step stepListNewStepToAttach : stepListNew) { - stepListNewStepToAttach = em.getReference(stepListNewStepToAttach.getClass(), stepListNewStepToAttach.getStepPK()); - attachedStepListNew.add(stepListNewStepToAttach); - } - stepListNew = attachedStepListNew; - testCase.setStepList(stepListNew); - testCase = em.merge(testCase); - for (TestPlan testPlanListOldTestPlan : testPlanListOld) { - if (!testPlanListNew.contains(testPlanListOldTestPlan)) { - testPlanListOldTestPlan.getTestCaseList().remove(testCase); - testPlanListOldTestPlan = em.merge(testPlanListOldTestPlan); - } - } - for (TestPlan testPlanListNewTestPlan : testPlanListNew) { - if (!testPlanListOld.contains(testPlanListNewTestPlan)) { - testPlanListNewTestPlan.getTestCaseList().add(testCase); - testPlanListNewTestPlan = em.merge(testPlanListNewTestPlan); - } - } - for (RiskControlHasTestCase riskControlHasTestCaseListNewRiskControlHasTestCase : riskControlHasTestCaseListNew) { - if (!riskControlHasTestCaseListOld.contains(riskControlHasTestCaseListNewRiskControlHasTestCase)) { - TestCase oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase = riskControlHasTestCaseListNewRiskControlHasTestCase.getTestCase(); - riskControlHasTestCaseListNewRiskControlHasTestCase.setTestCase(testCase); - riskControlHasTestCaseListNewRiskControlHasTestCase = em.merge(riskControlHasTestCaseListNewRiskControlHasTestCase); - if (oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase != null && !oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase.equals(testCase)) { - oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase.getRiskControlHasTestCaseList().remove(riskControlHasTestCaseListNewRiskControlHasTestCase); - oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase = em.merge(oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase); - } - } - } - for (Step stepListNewStep : stepListNew) { - if (!stepListOld.contains(stepListNewStep)) { - TestCase oldTestCaseOfStepListNewStep = stepListNewStep.getTestCase(); - stepListNewStep.setTestCase(testCase); - stepListNewStep = em.merge(stepListNewStep); - if (oldTestCaseOfStepListNewStep != null && !oldTestCaseOfStepListNewStep.equals(testCase)) { - oldTestCaseOfStepListNewStep.getStepList().remove(stepListNewStep); - oldTestCaseOfStepListNewStep = em.merge(oldTestCaseOfStepListNewStep); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = testCase.getId(); - if (findTestCase(id) == null) { - throw new NonexistentEntityException("The testCase with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - TestCase testCase; - try { - testCase = em.getReference(TestCase.class, id); - testCase.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The testCase with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List riskControlHasTestCaseListOrphanCheck = testCase.getRiskControlHasTestCaseList(); - for (RiskControlHasTestCase riskControlHasTestCaseListOrphanCheckRiskControlHasTestCase : riskControlHasTestCaseListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This TestCase (" + testCase + ") cannot be destroyed since the RiskControlHasTestCase " + riskControlHasTestCaseListOrphanCheckRiskControlHasTestCase + " in its riskControlHasTestCaseList field has a non-nullable testCase field."); - } - List stepListOrphanCheck = testCase.getStepList(); - for (Step stepListOrphanCheckStep : stepListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This TestCase (" + testCase + ") cannot be destroyed since the Step " + stepListOrphanCheckStep + " in its stepList field has a non-nullable testCase field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List testPlanList = testCase.getTestPlanList(); - for (TestPlan testPlanListTestPlan : testPlanList) { - testPlanListTestPlan.getTestCaseList().remove(testCase); - testPlanListTestPlan = em.merge(testPlanListTestPlan); - } - em.remove(testCase); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findTestCaseEntities() { - return findTestCaseEntities(true, -1, -1); - } - - public List findTestCaseEntities(int maxResults, int firstResult) { - return findTestCaseEntities(false, maxResults, firstResult); - } - - private List findTestCaseEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(TestCase.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public TestCase findTestCase(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(TestCase.class, id); - } - finally { - em.close(); - } - } - - public int getTestCaseCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(TestCase.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.TestPlan; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.RiskControlHasTestCase; +import com.validation.manager.core.db.Step; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class TestCaseJpaController implements Serializable { + + public TestCaseJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(TestCase testCase) { + if (testCase.getTestPlanList() == null) { + testCase.setTestPlanList(new ArrayList<>()); + } + if (testCase.getRiskControlHasTestCaseList() == null) { + testCase.setRiskControlHasTestCaseList(new ArrayList<>()); + } + if (testCase.getStepList() == null) { + testCase.setStepList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedTestPlanList = new ArrayList<>(); + for (TestPlan testPlanListTestPlanToAttach : testCase.getTestPlanList()) { + testPlanListTestPlanToAttach = em.getReference(testPlanListTestPlanToAttach.getClass(), testPlanListTestPlanToAttach.getTestPlanPK()); + attachedTestPlanList.add(testPlanListTestPlanToAttach); + } + testCase.setTestPlanList(attachedTestPlanList); + List attachedRiskControlHasTestCaseList = new ArrayList<>(); + for (RiskControlHasTestCase riskControlHasTestCaseListRiskControlHasTestCaseToAttach : testCase.getRiskControlHasTestCaseList()) { + riskControlHasTestCaseListRiskControlHasTestCaseToAttach = em.getReference(riskControlHasTestCaseListRiskControlHasTestCaseToAttach.getClass(), riskControlHasTestCaseListRiskControlHasTestCaseToAttach.getRiskControlHasTestCasePK()); + attachedRiskControlHasTestCaseList.add(riskControlHasTestCaseListRiskControlHasTestCaseToAttach); + } + testCase.setRiskControlHasTestCaseList(attachedRiskControlHasTestCaseList); + List attachedStepList = new ArrayList<>(); + for (Step stepListStepToAttach : testCase.getStepList()) { + stepListStepToAttach = em.getReference(stepListStepToAttach.getClass(), stepListStepToAttach.getStepPK()); + attachedStepList.add(stepListStepToAttach); + } + testCase.setStepList(attachedStepList); + em.persist(testCase); + for (TestPlan testPlanListTestPlan : testCase.getTestPlanList()) { + testPlanListTestPlan.getTestCaseList().add(testCase); + testPlanListTestPlan = em.merge(testPlanListTestPlan); + } + for (RiskControlHasTestCase riskControlHasTestCaseListRiskControlHasTestCase : testCase.getRiskControlHasTestCaseList()) { + TestCase oldTestCaseOfRiskControlHasTestCaseListRiskControlHasTestCase = riskControlHasTestCaseListRiskControlHasTestCase.getTestCase(); + riskControlHasTestCaseListRiskControlHasTestCase.setTestCase(testCase); + riskControlHasTestCaseListRiskControlHasTestCase = em.merge(riskControlHasTestCaseListRiskControlHasTestCase); + if (oldTestCaseOfRiskControlHasTestCaseListRiskControlHasTestCase != null) { + oldTestCaseOfRiskControlHasTestCaseListRiskControlHasTestCase.getRiskControlHasTestCaseList().remove(riskControlHasTestCaseListRiskControlHasTestCase); + oldTestCaseOfRiskControlHasTestCaseListRiskControlHasTestCase = em.merge(oldTestCaseOfRiskControlHasTestCaseListRiskControlHasTestCase); + } + } + for (Step stepListStep : testCase.getStepList()) { + TestCase oldTestCaseOfStepListStep = stepListStep.getTestCase(); + stepListStep.setTestCase(testCase); + stepListStep = em.merge(stepListStep); + if (oldTestCaseOfStepListStep != null) { + oldTestCaseOfStepListStep.getStepList().remove(stepListStep); + oldTestCaseOfStepListStep = em.merge(oldTestCaseOfStepListStep); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(TestCase testCase) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + TestCase persistentTestCase = em.find(TestCase.class, testCase.getId()); + List testPlanListOld = persistentTestCase.getTestPlanList(); + List testPlanListNew = testCase.getTestPlanList(); + List riskControlHasTestCaseListOld = persistentTestCase.getRiskControlHasTestCaseList(); + List riskControlHasTestCaseListNew = testCase.getRiskControlHasTestCaseList(); + List stepListOld = persistentTestCase.getStepList(); + List stepListNew = testCase.getStepList(); + List illegalOrphanMessages = null; + for (RiskControlHasTestCase riskControlHasTestCaseListOldRiskControlHasTestCase : riskControlHasTestCaseListOld) { + if (!riskControlHasTestCaseListNew.contains(riskControlHasTestCaseListOldRiskControlHasTestCase)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain RiskControlHasTestCase " + riskControlHasTestCaseListOldRiskControlHasTestCase + " since its testCase field is not nullable."); + } + } + for (Step stepListOldStep : stepListOld) { + if (!stepListNew.contains(stepListOldStep)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain Step " + stepListOldStep + " since its testCase field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedTestPlanListNew = new ArrayList<>(); + for (TestPlan testPlanListNewTestPlanToAttach : testPlanListNew) { + testPlanListNewTestPlanToAttach = em.getReference(testPlanListNewTestPlanToAttach.getClass(), testPlanListNewTestPlanToAttach.getTestPlanPK()); + attachedTestPlanListNew.add(testPlanListNewTestPlanToAttach); + } + testPlanListNew = attachedTestPlanListNew; + testCase.setTestPlanList(testPlanListNew); + List attachedRiskControlHasTestCaseListNew = new ArrayList<>(); + for (RiskControlHasTestCase riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach : riskControlHasTestCaseListNew) { + riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach = em.getReference(riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach.getClass(), riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach.getRiskControlHasTestCasePK()); + attachedRiskControlHasTestCaseListNew.add(riskControlHasTestCaseListNewRiskControlHasTestCaseToAttach); + } + riskControlHasTestCaseListNew = attachedRiskControlHasTestCaseListNew; + testCase.setRiskControlHasTestCaseList(riskControlHasTestCaseListNew); + List attachedStepListNew = new ArrayList<>(); + for (Step stepListNewStepToAttach : stepListNew) { + stepListNewStepToAttach = em.getReference(stepListNewStepToAttach.getClass(), stepListNewStepToAttach.getStepPK()); + attachedStepListNew.add(stepListNewStepToAttach); + } + stepListNew = attachedStepListNew; + testCase.setStepList(stepListNew); + testCase = em.merge(testCase); + for (TestPlan testPlanListOldTestPlan : testPlanListOld) { + if (!testPlanListNew.contains(testPlanListOldTestPlan)) { + testPlanListOldTestPlan.getTestCaseList().remove(testCase); + testPlanListOldTestPlan = em.merge(testPlanListOldTestPlan); + } + } + for (TestPlan testPlanListNewTestPlan : testPlanListNew) { + if (!testPlanListOld.contains(testPlanListNewTestPlan)) { + testPlanListNewTestPlan.getTestCaseList().add(testCase); + testPlanListNewTestPlan = em.merge(testPlanListNewTestPlan); + } + } + for (RiskControlHasTestCase riskControlHasTestCaseListNewRiskControlHasTestCase : riskControlHasTestCaseListNew) { + if (!riskControlHasTestCaseListOld.contains(riskControlHasTestCaseListNewRiskControlHasTestCase)) { + TestCase oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase = riskControlHasTestCaseListNewRiskControlHasTestCase.getTestCase(); + riskControlHasTestCaseListNewRiskControlHasTestCase.setTestCase(testCase); + riskControlHasTestCaseListNewRiskControlHasTestCase = em.merge(riskControlHasTestCaseListNewRiskControlHasTestCase); + if (oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase != null && !oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase.equals(testCase)) { + oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase.getRiskControlHasTestCaseList().remove(riskControlHasTestCaseListNewRiskControlHasTestCase); + oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase = em.merge(oldTestCaseOfRiskControlHasTestCaseListNewRiskControlHasTestCase); + } + } + } + for (Step stepListNewStep : stepListNew) { + if (!stepListOld.contains(stepListNewStep)) { + TestCase oldTestCaseOfStepListNewStep = stepListNewStep.getTestCase(); + stepListNewStep.setTestCase(testCase); + stepListNewStep = em.merge(stepListNewStep); + if (oldTestCaseOfStepListNewStep != null && !oldTestCaseOfStepListNewStep.equals(testCase)) { + oldTestCaseOfStepListNewStep.getStepList().remove(stepListNewStep); + oldTestCaseOfStepListNewStep = em.merge(oldTestCaseOfStepListNewStep); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = testCase.getId(); + if (findTestCase(id) == null) { + throw new NonexistentEntityException("The testCase with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + TestCase testCase; + try { + testCase = em.getReference(TestCase.class, id); + testCase.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The testCase with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List riskControlHasTestCaseListOrphanCheck = testCase.getRiskControlHasTestCaseList(); + for (RiskControlHasTestCase riskControlHasTestCaseListOrphanCheckRiskControlHasTestCase : riskControlHasTestCaseListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This TestCase (" + testCase + ") cannot be destroyed since the RiskControlHasTestCase " + riskControlHasTestCaseListOrphanCheckRiskControlHasTestCase + " in its riskControlHasTestCaseList field has a non-nullable testCase field."); + } + List stepListOrphanCheck = testCase.getStepList(); + for (Step stepListOrphanCheckStep : stepListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This TestCase (" + testCase + ") cannot be destroyed since the Step " + stepListOrphanCheckStep + " in its stepList field has a non-nullable testCase field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List testPlanList = testCase.getTestPlanList(); + for (TestPlan testPlanListTestPlan : testPlanList) { + testPlanListTestPlan.getTestCaseList().remove(testCase); + testPlanListTestPlan = em.merge(testPlanListTestPlan); + } + em.remove(testCase); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findTestCaseEntities() { + return findTestCaseEntities(true, -1, -1); + } + + public List findTestCaseEntities(int maxResults, int firstResult) { + return findTestCaseEntities(false, maxResults, firstResult); + } + + private List findTestCaseEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(TestCase.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public TestCase findTestCase(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(TestCase.class, id); + } + finally { + em.close(); + } + } + + public int getTestCaseCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(TestCase.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestPlanJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestPlanJpaController.java index 764716b7..ffd165a6 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestPlanJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestPlanJpaController.java @@ -13,368 +13,368 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.TestPlan; -import com.validation.manager.core.db.TestProject; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.TestPlanPK; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.UserTestPlanRole; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class TestPlanJpaController implements Serializable { - - public TestPlanJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(TestPlan testPlan) throws PreexistingEntityException, Exception { - if (testPlan.getTestPlanPK() == null) { - testPlan.setTestPlanPK(new TestPlanPK()); - } - if (testPlan.getTestCaseList() == null) { - testPlan.setTestCaseList(new ArrayList()); - } - if (testPlan.getTestPlanList() == null) { - testPlan.setTestPlanList(new ArrayList()); - } - if (testPlan.getUserTestPlanRoleList() == null) { - testPlan.setUserTestPlanRoleList(new ArrayList()); - } - testPlan.getTestPlanPK().setTestProjectId(testPlan.getTestProject().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - TestPlan testPlanRel = testPlan.getTestPlan(); - if (testPlanRel != null) { - testPlanRel = em.getReference(testPlanRel.getClass(), testPlanRel.getTestPlanPK()); - testPlan.setTestPlan(testPlanRel); - } - TestProject testProject = testPlan.getTestProject(); - if (testProject != null) { - testProject = em.getReference(testProject.getClass(), testProject.getId()); - testPlan.setTestProject(testProject); - } - List attachedTestCaseList = new ArrayList(); - for (TestCase testCaseListTestCaseToAttach : testPlan.getTestCaseList()) { - testCaseListTestCaseToAttach = em.getReference(testCaseListTestCaseToAttach.getClass(), testCaseListTestCaseToAttach.getId()); - attachedTestCaseList.add(testCaseListTestCaseToAttach); - } - testPlan.setTestCaseList(attachedTestCaseList); - List attachedTestPlanList = new ArrayList(); - for (TestPlan testPlanListTestPlanToAttach : testPlan.getTestPlanList()) { - testPlanListTestPlanToAttach = em.getReference(testPlanListTestPlanToAttach.getClass(), testPlanListTestPlanToAttach.getTestPlanPK()); - attachedTestPlanList.add(testPlanListTestPlanToAttach); - } - testPlan.setTestPlanList(attachedTestPlanList); - List attachedUserTestPlanRoleList = new ArrayList(); - for (UserTestPlanRole userTestPlanRoleListUserTestPlanRoleToAttach : testPlan.getUserTestPlanRoleList()) { - userTestPlanRoleListUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListUserTestPlanRoleToAttach.getUserTestPlanRolePK()); - attachedUserTestPlanRoleList.add(userTestPlanRoleListUserTestPlanRoleToAttach); - } - testPlan.setUserTestPlanRoleList(attachedUserTestPlanRoleList); - em.persist(testPlan); - if (testPlanRel != null) { - testPlanRel.getTestPlanList().add(testPlan); - testPlanRel = em.merge(testPlanRel); - } - if (testProject != null) { - testProject.getTestPlanList().add(testPlan); - testProject = em.merge(testProject); - } - for (TestCase testCaseListTestCase : testPlan.getTestCaseList()) { - testCaseListTestCase.getTestPlanList().add(testPlan); - testCaseListTestCase = em.merge(testCaseListTestCase); - } - for (TestPlan testPlanListTestPlan : testPlan.getTestPlanList()) { - TestPlan oldTestPlanOfTestPlanListTestPlan = testPlanListTestPlan.getTestPlan(); - testPlanListTestPlan.setTestPlan(testPlan); - testPlanListTestPlan = em.merge(testPlanListTestPlan); - if (oldTestPlanOfTestPlanListTestPlan != null) { - oldTestPlanOfTestPlanListTestPlan.getTestPlanList().remove(testPlanListTestPlan); - oldTestPlanOfTestPlanListTestPlan = em.merge(oldTestPlanOfTestPlanListTestPlan); - } - } - for (UserTestPlanRole userTestPlanRoleListUserTestPlanRole : testPlan.getUserTestPlanRoleList()) { - TestPlan oldTestPlanOfUserTestPlanRoleListUserTestPlanRole = userTestPlanRoleListUserTestPlanRole.getTestPlan(); - userTestPlanRoleListUserTestPlanRole.setTestPlan(testPlan); - userTestPlanRoleListUserTestPlanRole = em.merge(userTestPlanRoleListUserTestPlanRole); - if (oldTestPlanOfUserTestPlanRoleListUserTestPlanRole != null) { - oldTestPlanOfUserTestPlanRoleListUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListUserTestPlanRole); - oldTestPlanOfUserTestPlanRoleListUserTestPlanRole = em.merge(oldTestPlanOfUserTestPlanRoleListUserTestPlanRole); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - if (findTestPlan(testPlan.getTestPlanPK()) != null) { - throw new PreexistingEntityException("TestPlan " + testPlan + " already exists.", ex); - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(TestPlan testPlan) throws IllegalOrphanException, NonexistentEntityException, Exception { - testPlan.getTestPlanPK().setTestProjectId(testPlan.getTestProject().getId()); - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - TestPlan persistentTestPlan = em.find(TestPlan.class, testPlan.getTestPlanPK()); - TestPlan testPlanRelOld = persistentTestPlan.getTestPlan(); - TestPlan testPlanRelNew = testPlan.getTestPlan(); - TestProject testProjectOld = persistentTestPlan.getTestProject(); - TestProject testProjectNew = testPlan.getTestProject(); - List testCaseListOld = persistentTestPlan.getTestCaseList(); - List testCaseListNew = testPlan.getTestCaseList(); - List testPlanListOld = persistentTestPlan.getTestPlanList(); - List testPlanListNew = testPlan.getTestPlanList(); - List userTestPlanRoleListOld = persistentTestPlan.getUserTestPlanRoleList(); - List userTestPlanRoleListNew = testPlan.getUserTestPlanRoleList(); - List illegalOrphanMessages = null; - for (UserTestPlanRole userTestPlanRoleListOldUserTestPlanRole : userTestPlanRoleListOld) { - if (!userTestPlanRoleListNew.contains(userTestPlanRoleListOldUserTestPlanRole)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserTestPlanRole " + userTestPlanRoleListOldUserTestPlanRole + " since its testPlan field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (testPlanRelNew != null) { - testPlanRelNew = em.getReference(testPlanRelNew.getClass(), testPlanRelNew.getTestPlanPK()); - testPlan.setTestPlan(testPlanRelNew); - } - if (testProjectNew != null) { - testProjectNew = em.getReference(testProjectNew.getClass(), testProjectNew.getId()); - testPlan.setTestProject(testProjectNew); - } - List attachedTestCaseListNew = new ArrayList(); - for (TestCase testCaseListNewTestCaseToAttach : testCaseListNew) { - testCaseListNewTestCaseToAttach = em.getReference(testCaseListNewTestCaseToAttach.getClass(), testCaseListNewTestCaseToAttach.getId()); - attachedTestCaseListNew.add(testCaseListNewTestCaseToAttach); - } - testCaseListNew = attachedTestCaseListNew; - testPlan.setTestCaseList(testCaseListNew); - List attachedTestPlanListNew = new ArrayList(); - for (TestPlan testPlanListNewTestPlanToAttach : testPlanListNew) { - testPlanListNewTestPlanToAttach = em.getReference(testPlanListNewTestPlanToAttach.getClass(), testPlanListNewTestPlanToAttach.getTestPlanPK()); - attachedTestPlanListNew.add(testPlanListNewTestPlanToAttach); - } - testPlanListNew = attachedTestPlanListNew; - testPlan.setTestPlanList(testPlanListNew); - List attachedUserTestPlanRoleListNew = new ArrayList(); - for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRoleToAttach : userTestPlanRoleListNew) { - userTestPlanRoleListNewUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListNewUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListNewUserTestPlanRoleToAttach.getUserTestPlanRolePK()); - attachedUserTestPlanRoleListNew.add(userTestPlanRoleListNewUserTestPlanRoleToAttach); - } - userTestPlanRoleListNew = attachedUserTestPlanRoleListNew; - testPlan.setUserTestPlanRoleList(userTestPlanRoleListNew); - testPlan = em.merge(testPlan); - if (testPlanRelOld != null && !testPlanRelOld.equals(testPlanRelNew)) { - testPlanRelOld.getTestPlanList().remove(testPlan); - testPlanRelOld = em.merge(testPlanRelOld); - } - if (testPlanRelNew != null && !testPlanRelNew.equals(testPlanRelOld)) { - testPlanRelNew.getTestPlanList().add(testPlan); - testPlanRelNew = em.merge(testPlanRelNew); - } - if (testProjectOld != null && !testProjectOld.equals(testProjectNew)) { - testProjectOld.getTestPlanList().remove(testPlan); - testProjectOld = em.merge(testProjectOld); - } - if (testProjectNew != null && !testProjectNew.equals(testProjectOld)) { - testProjectNew.getTestPlanList().add(testPlan); - testProjectNew = em.merge(testProjectNew); - } - for (TestCase testCaseListOldTestCase : testCaseListOld) { - if (!testCaseListNew.contains(testCaseListOldTestCase)) { - testCaseListOldTestCase.getTestPlanList().remove(testPlan); - testCaseListOldTestCase = em.merge(testCaseListOldTestCase); - } - } - for (TestCase testCaseListNewTestCase : testCaseListNew) { - if (!testCaseListOld.contains(testCaseListNewTestCase)) { - testCaseListNewTestCase.getTestPlanList().add(testPlan); - testCaseListNewTestCase = em.merge(testCaseListNewTestCase); - } - } - for (TestPlan testPlanListOldTestPlan : testPlanListOld) { - if (!testPlanListNew.contains(testPlanListOldTestPlan)) { - testPlanListOldTestPlan.setTestPlan(null); - testPlanListOldTestPlan = em.merge(testPlanListOldTestPlan); - } - } - for (TestPlan testPlanListNewTestPlan : testPlanListNew) { - if (!testPlanListOld.contains(testPlanListNewTestPlan)) { - TestPlan oldTestPlanOfTestPlanListNewTestPlan = testPlanListNewTestPlan.getTestPlan(); - testPlanListNewTestPlan.setTestPlan(testPlan); - testPlanListNewTestPlan = em.merge(testPlanListNewTestPlan); - if (oldTestPlanOfTestPlanListNewTestPlan != null && !oldTestPlanOfTestPlanListNewTestPlan.equals(testPlan)) { - oldTestPlanOfTestPlanListNewTestPlan.getTestPlanList().remove(testPlanListNewTestPlan); - oldTestPlanOfTestPlanListNewTestPlan = em.merge(oldTestPlanOfTestPlanListNewTestPlan); - } - } - } - for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRole : userTestPlanRoleListNew) { - if (!userTestPlanRoleListOld.contains(userTestPlanRoleListNewUserTestPlanRole)) { - TestPlan oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole = userTestPlanRoleListNewUserTestPlanRole.getTestPlan(); - userTestPlanRoleListNewUserTestPlanRole.setTestPlan(testPlan); - userTestPlanRoleListNewUserTestPlanRole = em.merge(userTestPlanRoleListNewUserTestPlanRole); - if (oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole != null && !oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole.equals(testPlan)) { - oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListNewUserTestPlanRole); - oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole = em.merge(oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - TestPlanPK id = testPlan.getTestPlanPK(); - if (findTestPlan(id) == null) { - throw new NonexistentEntityException("The testPlan with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(TestPlanPK id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - TestPlan testPlan; - try { - testPlan = em.getReference(TestPlan.class, id); - testPlan.getTestPlanPK(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The testPlan with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List userTestPlanRoleListOrphanCheck = testPlan.getUserTestPlanRoleList(); - for (UserTestPlanRole userTestPlanRoleListOrphanCheckUserTestPlanRole : userTestPlanRoleListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This TestPlan (" + testPlan + ") cannot be destroyed since the UserTestPlanRole " + userTestPlanRoleListOrphanCheckUserTestPlanRole + " in its userTestPlanRoleList field has a non-nullable testPlan field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - TestPlan testPlanRel = testPlan.getTestPlan(); - if (testPlanRel != null) { - testPlanRel.getTestPlanList().remove(testPlan); - testPlanRel = em.merge(testPlanRel); - } - TestProject testProject = testPlan.getTestProject(); - if (testProject != null) { - testProject.getTestPlanList().remove(testPlan); - testProject = em.merge(testProject); - } - List testCaseList = testPlan.getTestCaseList(); - for (TestCase testCaseListTestCase : testCaseList) { - testCaseListTestCase.getTestPlanList().remove(testPlan); - testCaseListTestCase = em.merge(testCaseListTestCase); - } - List testPlanList = testPlan.getTestPlanList(); - for (TestPlan testPlanListTestPlan : testPlanList) { - testPlanListTestPlan.setTestPlan(null); - testPlanListTestPlan = em.merge(testPlanListTestPlan); - } - em.remove(testPlan); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findTestPlanEntities() { - return findTestPlanEntities(true, -1, -1); - } - - public List findTestPlanEntities(int maxResults, int firstResult) { - return findTestPlanEntities(false, maxResults, firstResult); - } - - private List findTestPlanEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(TestPlan.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public TestPlan findTestPlan(TestPlanPK id) { - EntityManager em = getEntityManager(); - try { - return em.find(TestPlan.class, id); - } - finally { - em.close(); - } - } - - public int getTestPlanCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(TestPlan.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.TestPlan; +import com.validation.manager.core.db.TestProject; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.TestPlanPK; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.UserTestPlanRole; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class TestPlanJpaController implements Serializable { + + public TestPlanJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(TestPlan testPlan) throws PreexistingEntityException, Exception { + if (testPlan.getTestPlanPK() == null) { + testPlan.setTestPlanPK(new TestPlanPK()); + } + if (testPlan.getTestCaseList() == null) { + testPlan.setTestCaseList(new ArrayList<>()); + } + if (testPlan.getTestPlanList() == null) { + testPlan.setTestPlanList(new ArrayList<>()); + } + if (testPlan.getUserTestPlanRoleList() == null) { + testPlan.setUserTestPlanRoleList(new ArrayList<>()); + } + testPlan.getTestPlanPK().setTestProjectId(testPlan.getTestProject().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + TestPlan testPlanRel = testPlan.getTestPlan(); + if (testPlanRel != null) { + testPlanRel = em.getReference(testPlanRel.getClass(), testPlanRel.getTestPlanPK()); + testPlan.setTestPlan(testPlanRel); + } + TestProject testProject = testPlan.getTestProject(); + if (testProject != null) { + testProject = em.getReference(testProject.getClass(), testProject.getId()); + testPlan.setTestProject(testProject); + } + List attachedTestCaseList = new ArrayList<>(); + for (TestCase testCaseListTestCaseToAttach : testPlan.getTestCaseList()) { + testCaseListTestCaseToAttach = em.getReference(testCaseListTestCaseToAttach.getClass(), testCaseListTestCaseToAttach.getId()); + attachedTestCaseList.add(testCaseListTestCaseToAttach); + } + testPlan.setTestCaseList(attachedTestCaseList); + List attachedTestPlanList = new ArrayList<>(); + for (TestPlan testPlanListTestPlanToAttach : testPlan.getTestPlanList()) { + testPlanListTestPlanToAttach = em.getReference(testPlanListTestPlanToAttach.getClass(), testPlanListTestPlanToAttach.getTestPlanPK()); + attachedTestPlanList.add(testPlanListTestPlanToAttach); + } + testPlan.setTestPlanList(attachedTestPlanList); + List attachedUserTestPlanRoleList = new ArrayList<>(); + for (UserTestPlanRole userTestPlanRoleListUserTestPlanRoleToAttach : testPlan.getUserTestPlanRoleList()) { + userTestPlanRoleListUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListUserTestPlanRoleToAttach.getUserTestPlanRolePK()); + attachedUserTestPlanRoleList.add(userTestPlanRoleListUserTestPlanRoleToAttach); + } + testPlan.setUserTestPlanRoleList(attachedUserTestPlanRoleList); + em.persist(testPlan); + if (testPlanRel != null) { + testPlanRel.getTestPlanList().add(testPlan); + testPlanRel = em.merge(testPlanRel); + } + if (testProject != null) { + testProject.getTestPlanList().add(testPlan); + testProject = em.merge(testProject); + } + for (TestCase testCaseListTestCase : testPlan.getTestCaseList()) { + testCaseListTestCase.getTestPlanList().add(testPlan); + testCaseListTestCase = em.merge(testCaseListTestCase); + } + for (TestPlan testPlanListTestPlan : testPlan.getTestPlanList()) { + TestPlan oldTestPlanOfTestPlanListTestPlan = testPlanListTestPlan.getTestPlan(); + testPlanListTestPlan.setTestPlan(testPlan); + testPlanListTestPlan = em.merge(testPlanListTestPlan); + if (oldTestPlanOfTestPlanListTestPlan != null) { + oldTestPlanOfTestPlanListTestPlan.getTestPlanList().remove(testPlanListTestPlan); + oldTestPlanOfTestPlanListTestPlan = em.merge(oldTestPlanOfTestPlanListTestPlan); + } + } + for (UserTestPlanRole userTestPlanRoleListUserTestPlanRole : testPlan.getUserTestPlanRoleList()) { + TestPlan oldTestPlanOfUserTestPlanRoleListUserTestPlanRole = userTestPlanRoleListUserTestPlanRole.getTestPlan(); + userTestPlanRoleListUserTestPlanRole.setTestPlan(testPlan); + userTestPlanRoleListUserTestPlanRole = em.merge(userTestPlanRoleListUserTestPlanRole); + if (oldTestPlanOfUserTestPlanRoleListUserTestPlanRole != null) { + oldTestPlanOfUserTestPlanRoleListUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListUserTestPlanRole); + oldTestPlanOfUserTestPlanRoleListUserTestPlanRole = em.merge(oldTestPlanOfUserTestPlanRoleListUserTestPlanRole); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + if (findTestPlan(testPlan.getTestPlanPK()) != null) { + throw new PreexistingEntityException("TestPlan " + testPlan + " already exists.", ex); + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(TestPlan testPlan) throws IllegalOrphanException, NonexistentEntityException, Exception { + testPlan.getTestPlanPK().setTestProjectId(testPlan.getTestProject().getId()); + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + TestPlan persistentTestPlan = em.find(TestPlan.class, testPlan.getTestPlanPK()); + TestPlan testPlanRelOld = persistentTestPlan.getTestPlan(); + TestPlan testPlanRelNew = testPlan.getTestPlan(); + TestProject testProjectOld = persistentTestPlan.getTestProject(); + TestProject testProjectNew = testPlan.getTestProject(); + List testCaseListOld = persistentTestPlan.getTestCaseList(); + List testCaseListNew = testPlan.getTestCaseList(); + List testPlanListOld = persistentTestPlan.getTestPlanList(); + List testPlanListNew = testPlan.getTestPlanList(); + List userTestPlanRoleListOld = persistentTestPlan.getUserTestPlanRoleList(); + List userTestPlanRoleListNew = testPlan.getUserTestPlanRoleList(); + List illegalOrphanMessages = null; + for (UserTestPlanRole userTestPlanRoleListOldUserTestPlanRole : userTestPlanRoleListOld) { + if (!userTestPlanRoleListNew.contains(userTestPlanRoleListOldUserTestPlanRole)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserTestPlanRole " + userTestPlanRoleListOldUserTestPlanRole + " since its testPlan field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (testPlanRelNew != null) { + testPlanRelNew = em.getReference(testPlanRelNew.getClass(), testPlanRelNew.getTestPlanPK()); + testPlan.setTestPlan(testPlanRelNew); + } + if (testProjectNew != null) { + testProjectNew = em.getReference(testProjectNew.getClass(), testProjectNew.getId()); + testPlan.setTestProject(testProjectNew); + } + List attachedTestCaseListNew = new ArrayList<>(); + for (TestCase testCaseListNewTestCaseToAttach : testCaseListNew) { + testCaseListNewTestCaseToAttach = em.getReference(testCaseListNewTestCaseToAttach.getClass(), testCaseListNewTestCaseToAttach.getId()); + attachedTestCaseListNew.add(testCaseListNewTestCaseToAttach); + } + testCaseListNew = attachedTestCaseListNew; + testPlan.setTestCaseList(testCaseListNew); + List attachedTestPlanListNew = new ArrayList<>(); + for (TestPlan testPlanListNewTestPlanToAttach : testPlanListNew) { + testPlanListNewTestPlanToAttach = em.getReference(testPlanListNewTestPlanToAttach.getClass(), testPlanListNewTestPlanToAttach.getTestPlanPK()); + attachedTestPlanListNew.add(testPlanListNewTestPlanToAttach); + } + testPlanListNew = attachedTestPlanListNew; + testPlan.setTestPlanList(testPlanListNew); + List attachedUserTestPlanRoleListNew = new ArrayList<>(); + for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRoleToAttach : userTestPlanRoleListNew) { + userTestPlanRoleListNewUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListNewUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListNewUserTestPlanRoleToAttach.getUserTestPlanRolePK()); + attachedUserTestPlanRoleListNew.add(userTestPlanRoleListNewUserTestPlanRoleToAttach); + } + userTestPlanRoleListNew = attachedUserTestPlanRoleListNew; + testPlan.setUserTestPlanRoleList(userTestPlanRoleListNew); + testPlan = em.merge(testPlan); + if (testPlanRelOld != null && !testPlanRelOld.equals(testPlanRelNew)) { + testPlanRelOld.getTestPlanList().remove(testPlan); + testPlanRelOld = em.merge(testPlanRelOld); + } + if (testPlanRelNew != null && !testPlanRelNew.equals(testPlanRelOld)) { + testPlanRelNew.getTestPlanList().add(testPlan); + testPlanRelNew = em.merge(testPlanRelNew); + } + if (testProjectOld != null && !testProjectOld.equals(testProjectNew)) { + testProjectOld.getTestPlanList().remove(testPlan); + testProjectOld = em.merge(testProjectOld); + } + if (testProjectNew != null && !testProjectNew.equals(testProjectOld)) { + testProjectNew.getTestPlanList().add(testPlan); + testProjectNew = em.merge(testProjectNew); + } + for (TestCase testCaseListOldTestCase : testCaseListOld) { + if (!testCaseListNew.contains(testCaseListOldTestCase)) { + testCaseListOldTestCase.getTestPlanList().remove(testPlan); + testCaseListOldTestCase = em.merge(testCaseListOldTestCase); + } + } + for (TestCase testCaseListNewTestCase : testCaseListNew) { + if (!testCaseListOld.contains(testCaseListNewTestCase)) { + testCaseListNewTestCase.getTestPlanList().add(testPlan); + testCaseListNewTestCase = em.merge(testCaseListNewTestCase); + } + } + for (TestPlan testPlanListOldTestPlan : testPlanListOld) { + if (!testPlanListNew.contains(testPlanListOldTestPlan)) { + testPlanListOldTestPlan.setTestPlan(null); + testPlanListOldTestPlan = em.merge(testPlanListOldTestPlan); + } + } + for (TestPlan testPlanListNewTestPlan : testPlanListNew) { + if (!testPlanListOld.contains(testPlanListNewTestPlan)) { + TestPlan oldTestPlanOfTestPlanListNewTestPlan = testPlanListNewTestPlan.getTestPlan(); + testPlanListNewTestPlan.setTestPlan(testPlan); + testPlanListNewTestPlan = em.merge(testPlanListNewTestPlan); + if (oldTestPlanOfTestPlanListNewTestPlan != null && !oldTestPlanOfTestPlanListNewTestPlan.equals(testPlan)) { + oldTestPlanOfTestPlanListNewTestPlan.getTestPlanList().remove(testPlanListNewTestPlan); + oldTestPlanOfTestPlanListNewTestPlan = em.merge(oldTestPlanOfTestPlanListNewTestPlan); + } + } + } + for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRole : userTestPlanRoleListNew) { + if (!userTestPlanRoleListOld.contains(userTestPlanRoleListNewUserTestPlanRole)) { + TestPlan oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole = userTestPlanRoleListNewUserTestPlanRole.getTestPlan(); + userTestPlanRoleListNewUserTestPlanRole.setTestPlan(testPlan); + userTestPlanRoleListNewUserTestPlanRole = em.merge(userTestPlanRoleListNewUserTestPlanRole); + if (oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole != null && !oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole.equals(testPlan)) { + oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListNewUserTestPlanRole); + oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole = em.merge(oldTestPlanOfUserTestPlanRoleListNewUserTestPlanRole); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + TestPlanPK id = testPlan.getTestPlanPK(); + if (findTestPlan(id) == null) { + throw new NonexistentEntityException("The testPlan with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(TestPlanPK id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + TestPlan testPlan; + try { + testPlan = em.getReference(TestPlan.class, id); + testPlan.getTestPlanPK(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The testPlan with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List userTestPlanRoleListOrphanCheck = testPlan.getUserTestPlanRoleList(); + for (UserTestPlanRole userTestPlanRoleListOrphanCheckUserTestPlanRole : userTestPlanRoleListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This TestPlan (" + testPlan + ") cannot be destroyed since the UserTestPlanRole " + userTestPlanRoleListOrphanCheckUserTestPlanRole + " in its userTestPlanRoleList field has a non-nullable testPlan field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + TestPlan testPlanRel = testPlan.getTestPlan(); + if (testPlanRel != null) { + testPlanRel.getTestPlanList().remove(testPlan); + testPlanRel = em.merge(testPlanRel); + } + TestProject testProject = testPlan.getTestProject(); + if (testProject != null) { + testProject.getTestPlanList().remove(testPlan); + testProject = em.merge(testProject); + } + List testCaseList = testPlan.getTestCaseList(); + for (TestCase testCaseListTestCase : testCaseList) { + testCaseListTestCase.getTestPlanList().remove(testPlan); + testCaseListTestCase = em.merge(testCaseListTestCase); + } + List testPlanList = testPlan.getTestPlanList(); + for (TestPlan testPlanListTestPlan : testPlanList) { + testPlanListTestPlan.setTestPlan(null); + testPlanListTestPlan = em.merge(testPlanListTestPlan); + } + em.remove(testPlan); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findTestPlanEntities() { + return findTestPlanEntities(true, -1, -1); + } + + public List findTestPlanEntities(int maxResults, int firstResult) { + return findTestPlanEntities(false, maxResults, firstResult); + } + + private List findTestPlanEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(TestPlan.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public TestPlan findTestPlan(TestPlanPK id) { + EntityManager em = getEntityManager(); + try { + return em.find(TestPlan.class, id); + } + finally { + em.close(); + } + } + + public int getTestPlanCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(TestPlan.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestProjectJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestProjectJpaController.java index aeb5ddc4..ff628e31 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestProjectJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/TestProjectJpaController.java @@ -13,303 +13,303 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Project; -import java.util.ArrayList; -import java.util.List; -import com.validation.manager.core.db.UserTestProjectRole; -import com.validation.manager.core.db.TestPlan; -import com.validation.manager.core.db.TestProject; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class TestProjectJpaController implements Serializable { - - public TestProjectJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(TestProject testProject) { - if (testProject.getProjectList() == null) { - testProject.setProjectList(new ArrayList()); - } - if (testProject.getUserTestProjectRoleList() == null) { - testProject.setUserTestProjectRoleList(new ArrayList()); - } - if (testProject.getTestPlanList() == null) { - testProject.setTestPlanList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedProjectList = new ArrayList(); - for (Project projectListProjectToAttach : testProject.getProjectList()) { - projectListProjectToAttach = em.getReference(projectListProjectToAttach.getClass(), projectListProjectToAttach.getId()); - attachedProjectList.add(projectListProjectToAttach); - } - testProject.setProjectList(attachedProjectList); - List attachedUserTestProjectRoleList = new ArrayList(); - for (UserTestProjectRole userTestProjectRoleListUserTestProjectRoleToAttach : testProject.getUserTestProjectRoleList()) { - userTestProjectRoleListUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListUserTestProjectRoleToAttach.getUserTestProjectRolePK()); - attachedUserTestProjectRoleList.add(userTestProjectRoleListUserTestProjectRoleToAttach); - } - testProject.setUserTestProjectRoleList(attachedUserTestProjectRoleList); - List attachedTestPlanList = new ArrayList(); - for (TestPlan testPlanListTestPlanToAttach : testProject.getTestPlanList()) { - testPlanListTestPlanToAttach = em.getReference(testPlanListTestPlanToAttach.getClass(), testPlanListTestPlanToAttach.getTestPlanPK()); - attachedTestPlanList.add(testPlanListTestPlanToAttach); - } - testProject.setTestPlanList(attachedTestPlanList); - em.persist(testProject); - for (Project projectListProject : testProject.getProjectList()) { - projectListProject.getTestProjectList().add(testProject); - projectListProject = em.merge(projectListProject); - } - for (UserTestProjectRole userTestProjectRoleListUserTestProjectRole : testProject.getUserTestProjectRoleList()) { - TestProject oldTestProjectOfUserTestProjectRoleListUserTestProjectRole = userTestProjectRoleListUserTestProjectRole.getTestProject(); - userTestProjectRoleListUserTestProjectRole.setTestProject(testProject); - userTestProjectRoleListUserTestProjectRole = em.merge(userTestProjectRoleListUserTestProjectRole); - if (oldTestProjectOfUserTestProjectRoleListUserTestProjectRole != null) { - oldTestProjectOfUserTestProjectRoleListUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListUserTestProjectRole); - oldTestProjectOfUserTestProjectRoleListUserTestProjectRole = em.merge(oldTestProjectOfUserTestProjectRoleListUserTestProjectRole); - } - } - for (TestPlan testPlanListTestPlan : testProject.getTestPlanList()) { - TestProject oldTestProjectOfTestPlanListTestPlan = testPlanListTestPlan.getTestProject(); - testPlanListTestPlan.setTestProject(testProject); - testPlanListTestPlan = em.merge(testPlanListTestPlan); - if (oldTestProjectOfTestPlanListTestPlan != null) { - oldTestProjectOfTestPlanListTestPlan.getTestPlanList().remove(testPlanListTestPlan); - oldTestProjectOfTestPlanListTestPlan = em.merge(oldTestProjectOfTestPlanListTestPlan); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(TestProject testProject) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - TestProject persistentTestProject = em.find(TestProject.class, testProject.getId()); - List projectListOld = persistentTestProject.getProjectList(); - List projectListNew = testProject.getProjectList(); - List userTestProjectRoleListOld = persistentTestProject.getUserTestProjectRoleList(); - List userTestProjectRoleListNew = testProject.getUserTestProjectRoleList(); - List testPlanListOld = persistentTestProject.getTestPlanList(); - List testPlanListNew = testProject.getTestPlanList(); - List illegalOrphanMessages = null; - for (UserTestProjectRole userTestProjectRoleListOldUserTestProjectRole : userTestProjectRoleListOld) { - if (!userTestProjectRoleListNew.contains(userTestProjectRoleListOldUserTestProjectRole)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserTestProjectRole " + userTestProjectRoleListOldUserTestProjectRole + " since its testProject field is not nullable."); - } - } - for (TestPlan testPlanListOldTestPlan : testPlanListOld) { - if (!testPlanListNew.contains(testPlanListOldTestPlan)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain TestPlan " + testPlanListOldTestPlan + " since its testProject field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedProjectListNew = new ArrayList(); - for (Project projectListNewProjectToAttach : projectListNew) { - projectListNewProjectToAttach = em.getReference(projectListNewProjectToAttach.getClass(), projectListNewProjectToAttach.getId()); - attachedProjectListNew.add(projectListNewProjectToAttach); - } - projectListNew = attachedProjectListNew; - testProject.setProjectList(projectListNew); - List attachedUserTestProjectRoleListNew = new ArrayList(); - for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRoleToAttach : userTestProjectRoleListNew) { - userTestProjectRoleListNewUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListNewUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListNewUserTestProjectRoleToAttach.getUserTestProjectRolePK()); - attachedUserTestProjectRoleListNew.add(userTestProjectRoleListNewUserTestProjectRoleToAttach); - } - userTestProjectRoleListNew = attachedUserTestProjectRoleListNew; - testProject.setUserTestProjectRoleList(userTestProjectRoleListNew); - List attachedTestPlanListNew = new ArrayList(); - for (TestPlan testPlanListNewTestPlanToAttach : testPlanListNew) { - testPlanListNewTestPlanToAttach = em.getReference(testPlanListNewTestPlanToAttach.getClass(), testPlanListNewTestPlanToAttach.getTestPlanPK()); - attachedTestPlanListNew.add(testPlanListNewTestPlanToAttach); - } - testPlanListNew = attachedTestPlanListNew; - testProject.setTestPlanList(testPlanListNew); - testProject = em.merge(testProject); - for (Project projectListOldProject : projectListOld) { - if (!projectListNew.contains(projectListOldProject)) { - projectListOldProject.getTestProjectList().remove(testProject); - projectListOldProject = em.merge(projectListOldProject); - } - } - for (Project projectListNewProject : projectListNew) { - if (!projectListOld.contains(projectListNewProject)) { - projectListNewProject.getTestProjectList().add(testProject); - projectListNewProject = em.merge(projectListNewProject); - } - } - for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRole : userTestProjectRoleListNew) { - if (!userTestProjectRoleListOld.contains(userTestProjectRoleListNewUserTestProjectRole)) { - TestProject oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole = userTestProjectRoleListNewUserTestProjectRole.getTestProject(); - userTestProjectRoleListNewUserTestProjectRole.setTestProject(testProject); - userTestProjectRoleListNewUserTestProjectRole = em.merge(userTestProjectRoleListNewUserTestProjectRole); - if (oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole != null && !oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole.equals(testProject)) { - oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListNewUserTestProjectRole); - oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole = em.merge(oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole); - } - } - } - for (TestPlan testPlanListNewTestPlan : testPlanListNew) { - if (!testPlanListOld.contains(testPlanListNewTestPlan)) { - TestProject oldTestProjectOfTestPlanListNewTestPlan = testPlanListNewTestPlan.getTestProject(); - testPlanListNewTestPlan.setTestProject(testProject); - testPlanListNewTestPlan = em.merge(testPlanListNewTestPlan); - if (oldTestProjectOfTestPlanListNewTestPlan != null && !oldTestProjectOfTestPlanListNewTestPlan.equals(testProject)) { - oldTestProjectOfTestPlanListNewTestPlan.getTestPlanList().remove(testPlanListNewTestPlan); - oldTestProjectOfTestPlanListNewTestPlan = em.merge(oldTestProjectOfTestPlanListNewTestPlan); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = testProject.getId(); - if (findTestProject(id) == null) { - throw new NonexistentEntityException("The testProject with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - TestProject testProject; - try { - testProject = em.getReference(TestProject.class, id); - testProject.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The testProject with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List userTestProjectRoleListOrphanCheck = testProject.getUserTestProjectRoleList(); - for (UserTestProjectRole userTestProjectRoleListOrphanCheckUserTestProjectRole : userTestProjectRoleListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This TestProject (" + testProject + ") cannot be destroyed since the UserTestProjectRole " + userTestProjectRoleListOrphanCheckUserTestProjectRole + " in its userTestProjectRoleList field has a non-nullable testProject field."); - } - List testPlanListOrphanCheck = testProject.getTestPlanList(); - for (TestPlan testPlanListOrphanCheckTestPlan : testPlanListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This TestProject (" + testProject + ") cannot be destroyed since the TestPlan " + testPlanListOrphanCheckTestPlan + " in its testPlanList field has a non-nullable testProject field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List projectList = testProject.getProjectList(); - for (Project projectListProject : projectList) { - projectListProject.getTestProjectList().remove(testProject); - projectListProject = em.merge(projectListProject); - } - em.remove(testProject); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findTestProjectEntities() { - return findTestProjectEntities(true, -1, -1); - } - - public List findTestProjectEntities(int maxResults, int firstResult) { - return findTestProjectEntities(false, maxResults, firstResult); - } - - private List findTestProjectEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(TestProject.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public TestProject findTestProject(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(TestProject.class, id); - } - finally { - em.close(); - } - } - - public int getTestProjectCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(TestProject.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Project; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.UserTestProjectRole; +import com.validation.manager.core.db.TestPlan; +import com.validation.manager.core.db.TestProject; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class TestProjectJpaController implements Serializable { + + public TestProjectJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(TestProject testProject) { + if (testProject.getProjectList() == null) { + testProject.setProjectList(new ArrayList<>()); + } + if (testProject.getUserTestProjectRoleList() == null) { + testProject.setUserTestProjectRoleList(new ArrayList<>()); + } + if (testProject.getTestPlanList() == null) { + testProject.setTestPlanList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedProjectList = new ArrayList<>(); + for (Project projectListProjectToAttach : testProject.getProjectList()) { + projectListProjectToAttach = em.getReference(projectListProjectToAttach.getClass(), projectListProjectToAttach.getId()); + attachedProjectList.add(projectListProjectToAttach); + } + testProject.setProjectList(attachedProjectList); + List attachedUserTestProjectRoleList = new ArrayList<>(); + for (UserTestProjectRole userTestProjectRoleListUserTestProjectRoleToAttach : testProject.getUserTestProjectRoleList()) { + userTestProjectRoleListUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListUserTestProjectRoleToAttach.getUserTestProjectRolePK()); + attachedUserTestProjectRoleList.add(userTestProjectRoleListUserTestProjectRoleToAttach); + } + testProject.setUserTestProjectRoleList(attachedUserTestProjectRoleList); + List attachedTestPlanList = new ArrayList<>(); + for (TestPlan testPlanListTestPlanToAttach : testProject.getTestPlanList()) { + testPlanListTestPlanToAttach = em.getReference(testPlanListTestPlanToAttach.getClass(), testPlanListTestPlanToAttach.getTestPlanPK()); + attachedTestPlanList.add(testPlanListTestPlanToAttach); + } + testProject.setTestPlanList(attachedTestPlanList); + em.persist(testProject); + for (Project projectListProject : testProject.getProjectList()) { + projectListProject.getTestProjectList().add(testProject); + projectListProject = em.merge(projectListProject); + } + for (UserTestProjectRole userTestProjectRoleListUserTestProjectRole : testProject.getUserTestProjectRoleList()) { + TestProject oldTestProjectOfUserTestProjectRoleListUserTestProjectRole = userTestProjectRoleListUserTestProjectRole.getTestProject(); + userTestProjectRoleListUserTestProjectRole.setTestProject(testProject); + userTestProjectRoleListUserTestProjectRole = em.merge(userTestProjectRoleListUserTestProjectRole); + if (oldTestProjectOfUserTestProjectRoleListUserTestProjectRole != null) { + oldTestProjectOfUserTestProjectRoleListUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListUserTestProjectRole); + oldTestProjectOfUserTestProjectRoleListUserTestProjectRole = em.merge(oldTestProjectOfUserTestProjectRoleListUserTestProjectRole); + } + } + for (TestPlan testPlanListTestPlan : testProject.getTestPlanList()) { + TestProject oldTestProjectOfTestPlanListTestPlan = testPlanListTestPlan.getTestProject(); + testPlanListTestPlan.setTestProject(testProject); + testPlanListTestPlan = em.merge(testPlanListTestPlan); + if (oldTestProjectOfTestPlanListTestPlan != null) { + oldTestProjectOfTestPlanListTestPlan.getTestPlanList().remove(testPlanListTestPlan); + oldTestProjectOfTestPlanListTestPlan = em.merge(oldTestProjectOfTestPlanListTestPlan); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(TestProject testProject) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + TestProject persistentTestProject = em.find(TestProject.class, testProject.getId()); + List projectListOld = persistentTestProject.getProjectList(); + List projectListNew = testProject.getProjectList(); + List userTestProjectRoleListOld = persistentTestProject.getUserTestProjectRoleList(); + List userTestProjectRoleListNew = testProject.getUserTestProjectRoleList(); + List testPlanListOld = persistentTestProject.getTestPlanList(); + List testPlanListNew = testProject.getTestPlanList(); + List illegalOrphanMessages = null; + for (UserTestProjectRole userTestProjectRoleListOldUserTestProjectRole : userTestProjectRoleListOld) { + if (!userTestProjectRoleListNew.contains(userTestProjectRoleListOldUserTestProjectRole)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserTestProjectRole " + userTestProjectRoleListOldUserTestProjectRole + " since its testProject field is not nullable."); + } + } + for (TestPlan testPlanListOldTestPlan : testPlanListOld) { + if (!testPlanListNew.contains(testPlanListOldTestPlan)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain TestPlan " + testPlanListOldTestPlan + " since its testProject field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedProjectListNew = new ArrayList<>(); + for (Project projectListNewProjectToAttach : projectListNew) { + projectListNewProjectToAttach = em.getReference(projectListNewProjectToAttach.getClass(), projectListNewProjectToAttach.getId()); + attachedProjectListNew.add(projectListNewProjectToAttach); + } + projectListNew = attachedProjectListNew; + testProject.setProjectList(projectListNew); + List attachedUserTestProjectRoleListNew = new ArrayList<>(); + for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRoleToAttach : userTestProjectRoleListNew) { + userTestProjectRoleListNewUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListNewUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListNewUserTestProjectRoleToAttach.getUserTestProjectRolePK()); + attachedUserTestProjectRoleListNew.add(userTestProjectRoleListNewUserTestProjectRoleToAttach); + } + userTestProjectRoleListNew = attachedUserTestProjectRoleListNew; + testProject.setUserTestProjectRoleList(userTestProjectRoleListNew); + List attachedTestPlanListNew = new ArrayList<>(); + for (TestPlan testPlanListNewTestPlanToAttach : testPlanListNew) { + testPlanListNewTestPlanToAttach = em.getReference(testPlanListNewTestPlanToAttach.getClass(), testPlanListNewTestPlanToAttach.getTestPlanPK()); + attachedTestPlanListNew.add(testPlanListNewTestPlanToAttach); + } + testPlanListNew = attachedTestPlanListNew; + testProject.setTestPlanList(testPlanListNew); + testProject = em.merge(testProject); + for (Project projectListOldProject : projectListOld) { + if (!projectListNew.contains(projectListOldProject)) { + projectListOldProject.getTestProjectList().remove(testProject); + projectListOldProject = em.merge(projectListOldProject); + } + } + for (Project projectListNewProject : projectListNew) { + if (!projectListOld.contains(projectListNewProject)) { + projectListNewProject.getTestProjectList().add(testProject); + projectListNewProject = em.merge(projectListNewProject); + } + } + for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRole : userTestProjectRoleListNew) { + if (!userTestProjectRoleListOld.contains(userTestProjectRoleListNewUserTestProjectRole)) { + TestProject oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole = userTestProjectRoleListNewUserTestProjectRole.getTestProject(); + userTestProjectRoleListNewUserTestProjectRole.setTestProject(testProject); + userTestProjectRoleListNewUserTestProjectRole = em.merge(userTestProjectRoleListNewUserTestProjectRole); + if (oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole != null && !oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole.equals(testProject)) { + oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListNewUserTestProjectRole); + oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole = em.merge(oldTestProjectOfUserTestProjectRoleListNewUserTestProjectRole); + } + } + } + for (TestPlan testPlanListNewTestPlan : testPlanListNew) { + if (!testPlanListOld.contains(testPlanListNewTestPlan)) { + TestProject oldTestProjectOfTestPlanListNewTestPlan = testPlanListNewTestPlan.getTestProject(); + testPlanListNewTestPlan.setTestProject(testProject); + testPlanListNewTestPlan = em.merge(testPlanListNewTestPlan); + if (oldTestProjectOfTestPlanListNewTestPlan != null && !oldTestProjectOfTestPlanListNewTestPlan.equals(testProject)) { + oldTestProjectOfTestPlanListNewTestPlan.getTestPlanList().remove(testPlanListNewTestPlan); + oldTestProjectOfTestPlanListNewTestPlan = em.merge(oldTestProjectOfTestPlanListNewTestPlan); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = testProject.getId(); + if (findTestProject(id) == null) { + throw new NonexistentEntityException("The testProject with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + TestProject testProject; + try { + testProject = em.getReference(TestProject.class, id); + testProject.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The testProject with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List userTestProjectRoleListOrphanCheck = testProject.getUserTestProjectRoleList(); + for (UserTestProjectRole userTestProjectRoleListOrphanCheckUserTestProjectRole : userTestProjectRoleListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This TestProject (" + testProject + ") cannot be destroyed since the UserTestProjectRole " + userTestProjectRoleListOrphanCheckUserTestProjectRole + " in its userTestProjectRoleList field has a non-nullable testProject field."); + } + List testPlanListOrphanCheck = testProject.getTestPlanList(); + for (TestPlan testPlanListOrphanCheckTestPlan : testPlanListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This TestProject (" + testProject + ") cannot be destroyed since the TestPlan " + testPlanListOrphanCheckTestPlan + " in its testPlanList field has a non-nullable testProject field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List projectList = testProject.getProjectList(); + for (Project projectListProject : projectList) { + projectListProject.getTestProjectList().remove(testProject); + projectListProject = em.merge(projectListProject); + } + em.remove(testProject); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findTestProjectEntities() { + return findTestProjectEntities(true, -1, -1); + } + + public List findTestProjectEntities(int maxResults, int firstResult) { + return findTestProjectEntities(false, maxResults, firstResult); + } + + private List findTestProjectEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(TestProject.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public TestProject findTestProject(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(TestProject.class, id); + } + finally { + em.close(); + } + } + + public int getTestProjectCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(TestProject.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/UserRightJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/UserRightJpaController.java index 83addca5..4eec04d6 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/UserRightJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/UserRightJpaController.java @@ -13,186 +13,186 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.Role; -import com.validation.manager.core.db.UserRight; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class UserRightJpaController implements Serializable { - - public UserRightJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(UserRight userRight) { - if (userRight.getRoleList() == null) { - userRight.setRoleList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedRoleList = new ArrayList(); - for (Role roleListRoleToAttach : userRight.getRoleList()) { - roleListRoleToAttach = em.getReference(roleListRoleToAttach.getClass(), roleListRoleToAttach.getId()); - attachedRoleList.add(roleListRoleToAttach); - } - userRight.setRoleList(attachedRoleList); - em.persist(userRight); - for (Role roleListRole : userRight.getRoleList()) { - roleListRole.getUserRightList().add(userRight); - roleListRole = em.merge(roleListRole); - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(UserRight userRight) throws NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - UserRight persistentUserRight = em.find(UserRight.class, userRight.getId()); - List roleListOld = persistentUserRight.getRoleList(); - List roleListNew = userRight.getRoleList(); - List attachedRoleListNew = new ArrayList(); - for (Role roleListNewRoleToAttach : roleListNew) { - roleListNewRoleToAttach = em.getReference(roleListNewRoleToAttach.getClass(), roleListNewRoleToAttach.getId()); - attachedRoleListNew.add(roleListNewRoleToAttach); - } - roleListNew = attachedRoleListNew; - userRight.setRoleList(roleListNew); - userRight = em.merge(userRight); - for (Role roleListOldRole : roleListOld) { - if (!roleListNew.contains(roleListOldRole)) { - roleListOldRole.getUserRightList().remove(userRight); - roleListOldRole = em.merge(roleListOldRole); - } - } - for (Role roleListNewRole : roleListNew) { - if (!roleListOld.contains(roleListNewRole)) { - roleListNewRole.getUserRightList().add(userRight); - roleListNewRole = em.merge(roleListNewRole); - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = userRight.getId(); - if (findUserRight(id) == null) { - throw new NonexistentEntityException("The userRight with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - UserRight userRight; - try { - userRight = em.getReference(UserRight.class, id); - userRight.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The userRight with id " + id + " no longer exists.", enfe); - } - List roleList = userRight.getRoleList(); - for (Role roleListRole : roleList) { - roleListRole.getUserRightList().remove(userRight); - roleListRole = em.merge(roleListRole); - } - em.remove(userRight); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findUserRightEntities() { - return findUserRightEntities(true, -1, -1); - } - - public List findUserRightEntities(int maxResults, int firstResult) { - return findUserRightEntities(false, maxResults, firstResult); - } - - private List findUserRightEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(UserRight.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public UserRight findUserRight(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(UserRight.class, id); - } - finally { - em.close(); - } - } - - public int getUserRightCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(UserRight.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.Role; +import com.validation.manager.core.db.UserRight; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class UserRightJpaController implements Serializable { + + public UserRightJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(UserRight userRight) { + if (userRight.getRoleList() == null) { + userRight.setRoleList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedRoleList = new ArrayList<>(); + for (Role roleListRoleToAttach : userRight.getRoleList()) { + roleListRoleToAttach = em.getReference(roleListRoleToAttach.getClass(), roleListRoleToAttach.getId()); + attachedRoleList.add(roleListRoleToAttach); + } + userRight.setRoleList(attachedRoleList); + em.persist(userRight); + for (Role roleListRole : userRight.getRoleList()) { + roleListRole.getUserRightList().add(userRight); + roleListRole = em.merge(roleListRole); + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(UserRight userRight) throws NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + UserRight persistentUserRight = em.find(UserRight.class, userRight.getId()); + List roleListOld = persistentUserRight.getRoleList(); + List roleListNew = userRight.getRoleList(); + List attachedRoleListNew = new ArrayList<>(); + for (Role roleListNewRoleToAttach : roleListNew) { + roleListNewRoleToAttach = em.getReference(roleListNewRoleToAttach.getClass(), roleListNewRoleToAttach.getId()); + attachedRoleListNew.add(roleListNewRoleToAttach); + } + roleListNew = attachedRoleListNew; + userRight.setRoleList(roleListNew); + userRight = em.merge(userRight); + for (Role roleListOldRole : roleListOld) { + if (!roleListNew.contains(roleListOldRole)) { + roleListOldRole.getUserRightList().remove(userRight); + roleListOldRole = em.merge(roleListOldRole); + } + } + for (Role roleListNewRole : roleListNew) { + if (!roleListOld.contains(roleListNewRole)) { + roleListNewRole.getUserRightList().add(userRight); + roleListNewRole = em.merge(roleListNewRole); + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = userRight.getId(); + if (findUserRight(id) == null) { + throw new NonexistentEntityException("The userRight with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + UserRight userRight; + try { + userRight = em.getReference(UserRight.class, id); + userRight.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The userRight with id " + id + " no longer exists.", enfe); + } + List roleList = userRight.getRoleList(); + for (Role roleListRole : roleList) { + roleListRole.getUserRightList().remove(userRight); + roleListRole = em.merge(roleListRole); + } + em.remove(userRight); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findUserRightEntities() { + return findUserRightEntities(true, -1, -1); + } + + public List findUserRightEntities(int maxResults, int firstResult) { + return findUserRightEntities(false, maxResults, firstResult); + } + + private List findUserRightEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(UserRight.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public UserRight findUserRight(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(UserRight.class, id); + } + finally { + em.close(); + } + } + + public int getUserRightCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(UserRight.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/UserStatusJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/UserStatusJpaController.java index 771b1c3a..ec8b3ce1 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/UserStatusJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/UserStatusJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.UserStatus; -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class UserStatusJpaController implements Serializable { - - public UserStatusJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(UserStatus userStatus) { - if (userStatus.getVmUserList() == null) { - userStatus.setVmUserList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedVmUserList = new ArrayList(); - for (VmUser vmUserListVmUserToAttach : userStatus.getVmUserList()) { - vmUserListVmUserToAttach = em.getReference(vmUserListVmUserToAttach.getClass(), vmUserListVmUserToAttach.getId()); - attachedVmUserList.add(vmUserListVmUserToAttach); - } - userStatus.setVmUserList(attachedVmUserList); - em.persist(userStatus); - for (VmUser vmUserListVmUser : userStatus.getVmUserList()) { - UserStatus oldUserStatusIdOfVmUserListVmUser = vmUserListVmUser.getUserStatusId(); - vmUserListVmUser.setUserStatusId(userStatus); - vmUserListVmUser = em.merge(vmUserListVmUser); - if (oldUserStatusIdOfVmUserListVmUser != null) { - oldUserStatusIdOfVmUserListVmUser.getVmUserList().remove(vmUserListVmUser); - oldUserStatusIdOfVmUserListVmUser = em.merge(oldUserStatusIdOfVmUserListVmUser); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(UserStatus userStatus) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - UserStatus persistentUserStatus = em.find(UserStatus.class, userStatus.getId()); - List vmUserListOld = persistentUserStatus.getVmUserList(); - List vmUserListNew = userStatus.getVmUserList(); - List illegalOrphanMessages = null; - for (VmUser vmUserListOldVmUser : vmUserListOld) { - if (!vmUserListNew.contains(vmUserListOldVmUser)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain VmUser " + vmUserListOldVmUser + " since its userStatusId field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedVmUserListNew = new ArrayList(); - for (VmUser vmUserListNewVmUserToAttach : vmUserListNew) { - vmUserListNewVmUserToAttach = em.getReference(vmUserListNewVmUserToAttach.getClass(), vmUserListNewVmUserToAttach.getId()); - attachedVmUserListNew.add(vmUserListNewVmUserToAttach); - } - vmUserListNew = attachedVmUserListNew; - userStatus.setVmUserList(vmUserListNew); - userStatus = em.merge(userStatus); - for (VmUser vmUserListNewVmUser : vmUserListNew) { - if (!vmUserListOld.contains(vmUserListNewVmUser)) { - UserStatus oldUserStatusIdOfVmUserListNewVmUser = vmUserListNewVmUser.getUserStatusId(); - vmUserListNewVmUser.setUserStatusId(userStatus); - vmUserListNewVmUser = em.merge(vmUserListNewVmUser); - if (oldUserStatusIdOfVmUserListNewVmUser != null && !oldUserStatusIdOfVmUserListNewVmUser.equals(userStatus)) { - oldUserStatusIdOfVmUserListNewVmUser.getVmUserList().remove(vmUserListNewVmUser); - oldUserStatusIdOfVmUserListNewVmUser = em.merge(oldUserStatusIdOfVmUserListNewVmUser); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = userStatus.getId(); - if (findUserStatus(id) == null) { - throw new NonexistentEntityException("The userStatus with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - UserStatus userStatus; - try { - userStatus = em.getReference(UserStatus.class, id); - userStatus.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The userStatus with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List vmUserListOrphanCheck = userStatus.getVmUserList(); - for (VmUser vmUserListOrphanCheckVmUser : vmUserListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This UserStatus (" + userStatus + ") cannot be destroyed since the VmUser " + vmUserListOrphanCheckVmUser + " in its vmUserList field has a non-nullable userStatusId field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(userStatus); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findUserStatusEntities() { - return findUserStatusEntities(true, -1, -1); - } - - public List findUserStatusEntities(int maxResults, int firstResult) { - return findUserStatusEntities(false, maxResults, firstResult); - } - - private List findUserStatusEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(UserStatus.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public UserStatus findUserStatus(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(UserStatus.class, id); - } - finally { - em.close(); - } - } - - public int getUserStatusCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(UserStatus.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import com.validation.manager.core.db.UserStatus; +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class UserStatusJpaController implements Serializable { + + public UserStatusJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(UserStatus userStatus) { + if (userStatus.getVmUserList() == null) { + userStatus.setVmUserList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedVmUserList = new ArrayList<>(); + for (VmUser vmUserListVmUserToAttach : userStatus.getVmUserList()) { + vmUserListVmUserToAttach = em.getReference(vmUserListVmUserToAttach.getClass(), vmUserListVmUserToAttach.getId()); + attachedVmUserList.add(vmUserListVmUserToAttach); + } + userStatus.setVmUserList(attachedVmUserList); + em.persist(userStatus); + for (VmUser vmUserListVmUser : userStatus.getVmUserList()) { + UserStatus oldUserStatusIdOfVmUserListVmUser = vmUserListVmUser.getUserStatusId(); + vmUserListVmUser.setUserStatusId(userStatus); + vmUserListVmUser = em.merge(vmUserListVmUser); + if (oldUserStatusIdOfVmUserListVmUser != null) { + oldUserStatusIdOfVmUserListVmUser.getVmUserList().remove(vmUserListVmUser); + oldUserStatusIdOfVmUserListVmUser = em.merge(oldUserStatusIdOfVmUserListVmUser); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(UserStatus userStatus) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + UserStatus persistentUserStatus = em.find(UserStatus.class, userStatus.getId()); + List vmUserListOld = persistentUserStatus.getVmUserList(); + List vmUserListNew = userStatus.getVmUserList(); + List illegalOrphanMessages = null; + for (VmUser vmUserListOldVmUser : vmUserListOld) { + if (!vmUserListNew.contains(vmUserListOldVmUser)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain VmUser " + vmUserListOldVmUser + " since its userStatusId field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedVmUserListNew = new ArrayList<>(); + for (VmUser vmUserListNewVmUserToAttach : vmUserListNew) { + vmUserListNewVmUserToAttach = em.getReference(vmUserListNewVmUserToAttach.getClass(), vmUserListNewVmUserToAttach.getId()); + attachedVmUserListNew.add(vmUserListNewVmUserToAttach); + } + vmUserListNew = attachedVmUserListNew; + userStatus.setVmUserList(vmUserListNew); + userStatus = em.merge(userStatus); + for (VmUser vmUserListNewVmUser : vmUserListNew) { + if (!vmUserListOld.contains(vmUserListNewVmUser)) { + UserStatus oldUserStatusIdOfVmUserListNewVmUser = vmUserListNewVmUser.getUserStatusId(); + vmUserListNewVmUser.setUserStatusId(userStatus); + vmUserListNewVmUser = em.merge(vmUserListNewVmUser); + if (oldUserStatusIdOfVmUserListNewVmUser != null && !oldUserStatusIdOfVmUserListNewVmUser.equals(userStatus)) { + oldUserStatusIdOfVmUserListNewVmUser.getVmUserList().remove(vmUserListNewVmUser); + oldUserStatusIdOfVmUserListNewVmUser = em.merge(oldUserStatusIdOfVmUserListNewVmUser); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = userStatus.getId(); + if (findUserStatus(id) == null) { + throw new NonexistentEntityException("The userStatus with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + UserStatus userStatus; + try { + userStatus = em.getReference(UserStatus.class, id); + userStatus.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The userStatus with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List vmUserListOrphanCheck = userStatus.getVmUserList(); + for (VmUser vmUserListOrphanCheckVmUser : vmUserListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This UserStatus (" + userStatus + ") cannot be destroyed since the VmUser " + vmUserListOrphanCheckVmUser + " in its vmUserList field has a non-nullable userStatusId field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(userStatus); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findUserStatusEntities() { + return findUserStatusEntities(true, -1, -1); + } + + public List findUserStatusEntities(int maxResults, int firstResult) { + return findUserStatusEntities(false, maxResults, firstResult); + } + + private List findUserStatusEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(UserStatus.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public UserStatus findUserStatus(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(UserStatus.class, id); + } + finally { + em.close(); + } + } + + public int getUserStatusCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(UserStatus.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/VmSettingJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/VmSettingJpaController.java index 9a1f195a..ae077189 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/VmSettingJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/VmSettingJpaController.java @@ -13,209 +13,209 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import java.io.Serializable; -import javax.persistence.Query; -import javax.persistence.EntityNotFoundException; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.VmSetting; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class VmSettingJpaController implements Serializable { - - public VmSettingJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(VmSetting vmSetting) { - if (vmSetting.getHistoryList() == null) { - vmSetting.setHistoryList(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - List attachedHistoryList = new ArrayList(); - for (History historyListHistoryToAttach : vmSetting.getHistoryList()) { - historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); - attachedHistoryList.add(historyListHistoryToAttach); - } - vmSetting.setHistoryList(attachedHistoryList); - em.persist(vmSetting); - for (History historyListHistory : vmSetting.getHistoryList()) { - VmSetting oldVmSettingIdOfHistoryListHistory = historyListHistory.getVmSettingId(); - historyListHistory.setVmSettingId(vmSetting); - historyListHistory = em.merge(historyListHistory); - if (oldVmSettingIdOfHistoryListHistory != null) { - oldVmSettingIdOfHistoryListHistory.getHistoryList().remove(historyListHistory); - oldVmSettingIdOfHistoryListHistory = em.merge(oldVmSettingIdOfHistoryListHistory); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(VmSetting vmSetting) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - VmSetting persistentVmSetting = em.find(VmSetting.class, vmSetting.getId()); - List historyListOld = persistentVmSetting.getHistoryList(); - List historyListNew = vmSetting.getHistoryList(); - List illegalOrphanMessages = null; - for (History historyListOldHistory : historyListOld) { - if (!historyListNew.contains(historyListOldHistory)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain History " + historyListOldHistory + " since its vmSettingId field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - List attachedHistoryListNew = new ArrayList(); - for (History historyListNewHistoryToAttach : historyListNew) { - historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); - attachedHistoryListNew.add(historyListNewHistoryToAttach); - } - historyListNew = attachedHistoryListNew; - vmSetting.setHistoryList(historyListNew); - vmSetting = em.merge(vmSetting); - for (History historyListNewHistory : historyListNew) { - if (!historyListOld.contains(historyListNewHistory)) { - VmSetting oldVmSettingIdOfHistoryListNewHistory = historyListNewHistory.getVmSettingId(); - historyListNewHistory.setVmSettingId(vmSetting); - historyListNewHistory = em.merge(historyListNewHistory); - if (oldVmSettingIdOfHistoryListNewHistory != null && !oldVmSettingIdOfHistoryListNewHistory.equals(vmSetting)) { - oldVmSettingIdOfHistoryListNewHistory.getHistoryList().remove(historyListNewHistory); - oldVmSettingIdOfHistoryListNewHistory = em.merge(oldVmSettingIdOfHistoryListNewHistory); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = vmSetting.getId(); - if (findVmSetting(id) == null) { - throw new NonexistentEntityException("The vmSetting with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - VmSetting vmSetting; - try { - vmSetting = em.getReference(VmSetting.class, id); - vmSetting.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The vmSetting with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List historyListOrphanCheck = vmSetting.getHistoryList(); - for (History historyListOrphanCheckHistory : historyListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This VmSetting (" + vmSetting + ") cannot be destroyed since the History " + historyListOrphanCheckHistory + " in its historyList field has a non-nullable vmSettingId field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - em.remove(vmSetting); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findVmSettingEntities() { - return findVmSettingEntities(true, -1, -1); - } - - public List findVmSettingEntities(int maxResults, int firstResult) { - return findVmSettingEntities(false, maxResults, firstResult); - } - - private List findVmSettingEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(VmSetting.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public VmSetting findVmSetting(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(VmSetting.class, id); - } - finally { - em.close(); - } - } - - public int getVmSettingCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(VmSetting.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.VmSetting; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class VmSettingJpaController implements Serializable { + + public VmSettingJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(VmSetting vmSetting) { + if (vmSetting.getHistoryList() == null) { + vmSetting.setHistoryList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + List attachedHistoryList = new ArrayList<>(); + for (History historyListHistoryToAttach : vmSetting.getHistoryList()) { + historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); + attachedHistoryList.add(historyListHistoryToAttach); + } + vmSetting.setHistoryList(attachedHistoryList); + em.persist(vmSetting); + for (History historyListHistory : vmSetting.getHistoryList()) { + VmSetting oldVmSettingIdOfHistoryListHistory = historyListHistory.getVmSettingId(); + historyListHistory.setVmSettingId(vmSetting); + historyListHistory = em.merge(historyListHistory); + if (oldVmSettingIdOfHistoryListHistory != null) { + oldVmSettingIdOfHistoryListHistory.getHistoryList().remove(historyListHistory); + oldVmSettingIdOfHistoryListHistory = em.merge(oldVmSettingIdOfHistoryListHistory); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(VmSetting vmSetting) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + VmSetting persistentVmSetting = em.find(VmSetting.class, vmSetting.getId()); + List historyListOld = persistentVmSetting.getHistoryList(); + List historyListNew = vmSetting.getHistoryList(); + List illegalOrphanMessages = null; + for (History historyListOldHistory : historyListOld) { + if (!historyListNew.contains(historyListOldHistory)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain History " + historyListOldHistory + " since its vmSettingId field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + List attachedHistoryListNew = new ArrayList<>(); + for (History historyListNewHistoryToAttach : historyListNew) { + historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); + attachedHistoryListNew.add(historyListNewHistoryToAttach); + } + historyListNew = attachedHistoryListNew; + vmSetting.setHistoryList(historyListNew); + vmSetting = em.merge(vmSetting); + for (History historyListNewHistory : historyListNew) { + if (!historyListOld.contains(historyListNewHistory)) { + VmSetting oldVmSettingIdOfHistoryListNewHistory = historyListNewHistory.getVmSettingId(); + historyListNewHistory.setVmSettingId(vmSetting); + historyListNewHistory = em.merge(historyListNewHistory); + if (oldVmSettingIdOfHistoryListNewHistory != null && !oldVmSettingIdOfHistoryListNewHistory.equals(vmSetting)) { + oldVmSettingIdOfHistoryListNewHistory.getHistoryList().remove(historyListNewHistory); + oldVmSettingIdOfHistoryListNewHistory = em.merge(oldVmSettingIdOfHistoryListNewHistory); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = vmSetting.getId(); + if (findVmSetting(id) == null) { + throw new NonexistentEntityException("The vmSetting with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + VmSetting vmSetting; + try { + vmSetting = em.getReference(VmSetting.class, id); + vmSetting.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The vmSetting with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List historyListOrphanCheck = vmSetting.getHistoryList(); + for (History historyListOrphanCheckHistory : historyListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmSetting (" + vmSetting + ") cannot be destroyed since the History " + historyListOrphanCheckHistory + " in its historyList field has a non-nullable vmSettingId field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + em.remove(vmSetting); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findVmSettingEntities() { + return findVmSettingEntities(true, -1, -1); + } + + public List findVmSettingEntities(int maxResults, int firstResult) { + return findVmSettingEntities(false, maxResults, firstResult); + } + + private List findVmSettingEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(VmSetting.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public VmSetting findVmSetting(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(VmSetting.class, id); + } + finally { + em.close(); + } + } + + public int getVmSettingCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(VmSetting.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/db/controller/VmUserJpaController.java b/VM-Core/src/main/java/com/validation/manager/core/db/controller/VmUserJpaController.java index e0b7e761..ae05777e 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/db/controller/VmUserJpaController.java +++ b/VM-Core/src/main/java/com/validation/manager/core/db/controller/VmUserJpaController.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,981 +13,1034 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db.controller; - -import com.validation.manager.core.db.CorrectiveAction; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.ExecutionStepHasIssue; -import com.validation.manager.core.db.ExecutionStepHasVmUser; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.Notification; -import com.validation.manager.core.db.Role; -import com.validation.manager.core.db.RootCause; -import com.validation.manager.core.db.UserAssigment; -import com.validation.manager.core.db.UserHasInvestigation; -import com.validation.manager.core.db.UserModifiedRecord; -import com.validation.manager.core.db.UserStatus; -import com.validation.manager.core.db.UserTestPlanRole; -import com.validation.manager.core.db.UserTestProjectRole; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.io.Serializable; -import java.util.ArrayList; -import java.util.List; -import javax.persistence.EntityManager; -import javax.persistence.EntityManagerFactory; -import javax.persistence.EntityNotFoundException; -import javax.persistence.Query; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class VmUserJpaController implements Serializable { - - public VmUserJpaController(EntityManagerFactory emf) { - this.emf = emf; - } - private EntityManagerFactory emf = null; - - public EntityManager getEntityManager() { - return emf.createEntityManager(); - } - - public void create(VmUser vmUser) { - if (vmUser.getCorrectiveActionList() == null) { - vmUser.setCorrectiveActionList(new ArrayList()); - } - if (vmUser.getRoleList() == null) { - vmUser.setRoleList(new ArrayList()); - } - if (vmUser.getRootCauseList() == null) { - vmUser.setRootCauseList(new ArrayList()); - } - if (vmUser.getExecutionStepList() == null) { - vmUser.setExecutionStepList(new ArrayList()); - } - if (vmUser.getExecutionStepList1() == null) { - vmUser.setExecutionStepList1(new ArrayList()); - } - if (vmUser.getUserTestProjectRoleList() == null) { - vmUser.setUserTestProjectRoleList(new ArrayList()); - } - if (vmUser.getUserTestPlanRoleList() == null) { - vmUser.setUserTestPlanRoleList(new ArrayList()); - } - if (vmUser.getUserModifiedRecordList() == null) { - vmUser.setUserModifiedRecordList(new ArrayList()); - } - if (vmUser.getUserHasInvestigationList() == null) { - vmUser.setUserHasInvestigationList(new ArrayList()); - } - if (vmUser.getUserAssigmentList() == null) { - vmUser.setUserAssigmentList(new ArrayList()); - } - if (vmUser.getUserAssigmentList1() == null) { - vmUser.setUserAssigmentList1(new ArrayList()); - } - if (vmUser.getExecutionStepHasIssueList() == null) { - vmUser.setExecutionStepHasIssueList(new ArrayList()); - } - if (vmUser.getExecutionStepHasVmUserList() == null) { - vmUser.setExecutionStepHasVmUserList(new ArrayList()); - } - if (vmUser.getHistoryModificationList() == null) { - vmUser.setHistoryModificationList(new ArrayList()); - } - if (vmUser.getNotificationList() == null) { - vmUser.setNotificationList(new ArrayList()); - } - if (vmUser.getNotificationList1() == null) { - vmUser.setNotificationList1(new ArrayList()); - } - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - UserStatus userStatusId = vmUser.getUserStatusId(); - if (userStatusId != null) { - userStatusId = em.getReference(userStatusId.getClass(), userStatusId.getId()); - vmUser.setUserStatusId(userStatusId); - } - List attachedCorrectiveActionList = new ArrayList(); - for (CorrectiveAction correctiveActionListCorrectiveActionToAttach : vmUser.getCorrectiveActionList()) { - correctiveActionListCorrectiveActionToAttach = em.getReference(correctiveActionListCorrectiveActionToAttach.getClass(), correctiveActionListCorrectiveActionToAttach.getId()); - attachedCorrectiveActionList.add(correctiveActionListCorrectiveActionToAttach); - } - vmUser.setCorrectiveActionList(attachedCorrectiveActionList); - List attachedRoleList = new ArrayList(); - for (Role roleListRoleToAttach : vmUser.getRoleList()) { - roleListRoleToAttach = em.getReference(roleListRoleToAttach.getClass(), roleListRoleToAttach.getId()); - attachedRoleList.add(roleListRoleToAttach); - } - vmUser.setRoleList(attachedRoleList); - List attachedRootCauseList = new ArrayList(); - for (RootCause rootCauseListRootCauseToAttach : vmUser.getRootCauseList()) { - rootCauseListRootCauseToAttach = em.getReference(rootCauseListRootCauseToAttach.getClass(), rootCauseListRootCauseToAttach.getRootCausePK()); - attachedRootCauseList.add(rootCauseListRootCauseToAttach); - } - vmUser.setRootCauseList(attachedRootCauseList); - List attachedExecutionStepList = new ArrayList(); - for (ExecutionStep executionStepListExecutionStepToAttach : vmUser.getExecutionStepList()) { - executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepList.add(executionStepListExecutionStepToAttach); - } - vmUser.setExecutionStepList(attachedExecutionStepList); - List attachedExecutionStepList1 = new ArrayList(); - for (ExecutionStep executionStepList1ExecutionStepToAttach : vmUser.getExecutionStepList1()) { - executionStepList1ExecutionStepToAttach = em.getReference(executionStepList1ExecutionStepToAttach.getClass(), executionStepList1ExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepList1.add(executionStepList1ExecutionStepToAttach); - } - vmUser.setExecutionStepList1(attachedExecutionStepList1); - List attachedUserTestProjectRoleList = new ArrayList(); - for (UserTestProjectRole userTestProjectRoleListUserTestProjectRoleToAttach : vmUser.getUserTestProjectRoleList()) { - userTestProjectRoleListUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListUserTestProjectRoleToAttach.getUserTestProjectRolePK()); - attachedUserTestProjectRoleList.add(userTestProjectRoleListUserTestProjectRoleToAttach); - } - vmUser.setUserTestProjectRoleList(attachedUserTestProjectRoleList); - List attachedUserTestPlanRoleList = new ArrayList(); - for (UserTestPlanRole userTestPlanRoleListUserTestPlanRoleToAttach : vmUser.getUserTestPlanRoleList()) { - userTestPlanRoleListUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListUserTestPlanRoleToAttach.getUserTestPlanRolePK()); - attachedUserTestPlanRoleList.add(userTestPlanRoleListUserTestPlanRoleToAttach); - } - vmUser.setUserTestPlanRoleList(attachedUserTestPlanRoleList); - List attachedUserModifiedRecordList = new ArrayList(); - for (UserModifiedRecord userModifiedRecordListUserModifiedRecordToAttach : vmUser.getUserModifiedRecordList()) { - userModifiedRecordListUserModifiedRecordToAttach = em.getReference(userModifiedRecordListUserModifiedRecordToAttach.getClass(), userModifiedRecordListUserModifiedRecordToAttach.getUserModifiedRecordPK()); - attachedUserModifiedRecordList.add(userModifiedRecordListUserModifiedRecordToAttach); - } - vmUser.setUserModifiedRecordList(attachedUserModifiedRecordList); - List attachedUserHasInvestigationList = new ArrayList(); - for (UserHasInvestigation userHasInvestigationListUserHasInvestigationToAttach : vmUser.getUserHasInvestigationList()) { - userHasInvestigationListUserHasInvestigationToAttach = em.getReference(userHasInvestigationListUserHasInvestigationToAttach.getClass(), userHasInvestigationListUserHasInvestigationToAttach.getUserHasInvestigationPK()); - attachedUserHasInvestigationList.add(userHasInvestigationListUserHasInvestigationToAttach); - } - vmUser.setUserHasInvestigationList(attachedUserHasInvestigationList); - List attachedUserAssigmentList = new ArrayList(); - for (UserAssigment userAssigmentListUserAssigmentToAttach : vmUser.getUserAssigmentList()) { - userAssigmentListUserAssigmentToAttach = em.getReference(userAssigmentListUserAssigmentToAttach.getClass(), userAssigmentListUserAssigmentToAttach.getUserAssigmentPK()); - attachedUserAssigmentList.add(userAssigmentListUserAssigmentToAttach); - } - vmUser.setUserAssigmentList(attachedUserAssigmentList); - List attachedUserAssigmentList1 = new ArrayList(); - for (UserAssigment userAssigmentList1UserAssigmentToAttach : vmUser.getUserAssigmentList1()) { - userAssigmentList1UserAssigmentToAttach = em.getReference(userAssigmentList1UserAssigmentToAttach.getClass(), userAssigmentList1UserAssigmentToAttach.getUserAssigmentPK()); - attachedUserAssigmentList1.add(userAssigmentList1UserAssigmentToAttach); - } - vmUser.setUserAssigmentList1(attachedUserAssigmentList1); - List attachedExecutionStepHasIssueList = new ArrayList(); - for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssueToAttach : vmUser.getExecutionStepHasIssueList()) { - executionStepHasIssueListExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); - attachedExecutionStepHasIssueList.add(executionStepHasIssueListExecutionStepHasIssueToAttach); - } - vmUser.setExecutionStepHasIssueList(attachedExecutionStepHasIssueList); - List attachedExecutionStepHasVmUserList = new ArrayList(); - for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUserToAttach : vmUser.getExecutionStepHasVmUserList()) { - executionStepHasVmUserListExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); - attachedExecutionStepHasVmUserList.add(executionStepHasVmUserListExecutionStepHasVmUserToAttach); - } - vmUser.setExecutionStepHasVmUserList(attachedExecutionStepHasVmUserList); - List attachedHistoryModificationList = new ArrayList(); - for (History historyModificationListHistoryToAttach : vmUser.getHistoryModificationList()) { - historyModificationListHistoryToAttach = em.getReference(historyModificationListHistoryToAttach.getClass(), historyModificationListHistoryToAttach.getId()); - attachedHistoryModificationList.add(historyModificationListHistoryToAttach); - } - vmUser.setHistoryModificationList(attachedHistoryModificationList); - List attachedNotificationList = new ArrayList(); - for (Notification notificationListNotificationToAttach : vmUser.getNotificationList()) { - notificationListNotificationToAttach = em.getReference(notificationListNotificationToAttach.getClass(), notificationListNotificationToAttach.getNotificationPK()); - attachedNotificationList.add(notificationListNotificationToAttach); - } - vmUser.setNotificationList(attachedNotificationList); - List attachedNotificationList1 = new ArrayList(); - for (Notification notificationList1NotificationToAttach : vmUser.getNotificationList1()) { - notificationList1NotificationToAttach = em.getReference(notificationList1NotificationToAttach.getClass(), notificationList1NotificationToAttach.getNotificationPK()); - attachedNotificationList1.add(notificationList1NotificationToAttach); - } - vmUser.setNotificationList1(attachedNotificationList1); - em.persist(vmUser); - if (userStatusId != null) { - userStatusId.getVmUserList().add(vmUser); - userStatusId = em.merge(userStatusId); - } - for (CorrectiveAction correctiveActionListCorrectiveAction : vmUser.getCorrectiveActionList()) { - correctiveActionListCorrectiveAction.getVmUserList().add(vmUser); - correctiveActionListCorrectiveAction = em.merge(correctiveActionListCorrectiveAction); - } - for (Role roleListRole : vmUser.getRoleList()) { - roleListRole.getVmUserList().add(vmUser); - roleListRole = em.merge(roleListRole); - } - for (RootCause rootCauseListRootCause : vmUser.getRootCauseList()) { - rootCauseListRootCause.getVmUserList().add(vmUser); - rootCauseListRootCause = em.merge(rootCauseListRootCause); - } - for (ExecutionStep executionStepListExecutionStep : vmUser.getExecutionStepList()) { - VmUser oldAssigneeOfExecutionStepListExecutionStep = executionStepListExecutionStep.getAssignee(); - executionStepListExecutionStep.setAssignee(vmUser); - executionStepListExecutionStep = em.merge(executionStepListExecutionStep); - if (oldAssigneeOfExecutionStepListExecutionStep != null) { - oldAssigneeOfExecutionStepListExecutionStep.getExecutionStepList().remove(executionStepListExecutionStep); - oldAssigneeOfExecutionStepListExecutionStep = em.merge(oldAssigneeOfExecutionStepListExecutionStep); - } - } - for (ExecutionStep executionStepList1ExecutionStep : vmUser.getExecutionStepList1()) { - VmUser oldAssignerOfExecutionStepList1ExecutionStep = executionStepList1ExecutionStep.getAssigner(); - executionStepList1ExecutionStep.setAssigner(vmUser); - executionStepList1ExecutionStep = em.merge(executionStepList1ExecutionStep); - if (oldAssignerOfExecutionStepList1ExecutionStep != null) { - oldAssignerOfExecutionStepList1ExecutionStep.getExecutionStepList1().remove(executionStepList1ExecutionStep); - oldAssignerOfExecutionStepList1ExecutionStep = em.merge(oldAssignerOfExecutionStepList1ExecutionStep); - } - } - for (UserTestProjectRole userTestProjectRoleListUserTestProjectRole : vmUser.getUserTestProjectRoleList()) { - VmUser oldVmUserOfUserTestProjectRoleListUserTestProjectRole = userTestProjectRoleListUserTestProjectRole.getVmUser(); - userTestProjectRoleListUserTestProjectRole.setVmUser(vmUser); - userTestProjectRoleListUserTestProjectRole = em.merge(userTestProjectRoleListUserTestProjectRole); - if (oldVmUserOfUserTestProjectRoleListUserTestProjectRole != null) { - oldVmUserOfUserTestProjectRoleListUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListUserTestProjectRole); - oldVmUserOfUserTestProjectRoleListUserTestProjectRole = em.merge(oldVmUserOfUserTestProjectRoleListUserTestProjectRole); - } - } - for (UserTestPlanRole userTestPlanRoleListUserTestPlanRole : vmUser.getUserTestPlanRoleList()) { - VmUser oldVmUserOfUserTestPlanRoleListUserTestPlanRole = userTestPlanRoleListUserTestPlanRole.getVmUser(); - userTestPlanRoleListUserTestPlanRole.setVmUser(vmUser); - userTestPlanRoleListUserTestPlanRole = em.merge(userTestPlanRoleListUserTestPlanRole); - if (oldVmUserOfUserTestPlanRoleListUserTestPlanRole != null) { - oldVmUserOfUserTestPlanRoleListUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListUserTestPlanRole); - oldVmUserOfUserTestPlanRoleListUserTestPlanRole = em.merge(oldVmUserOfUserTestPlanRoleListUserTestPlanRole); - } - } - for (UserModifiedRecord userModifiedRecordListUserModifiedRecord : vmUser.getUserModifiedRecordList()) { - VmUser oldVmUserOfUserModifiedRecordListUserModifiedRecord = userModifiedRecordListUserModifiedRecord.getVmUser(); - userModifiedRecordListUserModifiedRecord.setVmUser(vmUser); - userModifiedRecordListUserModifiedRecord = em.merge(userModifiedRecordListUserModifiedRecord); - if (oldVmUserOfUserModifiedRecordListUserModifiedRecord != null) { - oldVmUserOfUserModifiedRecordListUserModifiedRecord.getUserModifiedRecordList().remove(userModifiedRecordListUserModifiedRecord); - oldVmUserOfUserModifiedRecordListUserModifiedRecord = em.merge(oldVmUserOfUserModifiedRecordListUserModifiedRecord); - } - } - for (UserHasInvestigation userHasInvestigationListUserHasInvestigation : vmUser.getUserHasInvestigationList()) { - VmUser oldVmUserOfUserHasInvestigationListUserHasInvestigation = userHasInvestigationListUserHasInvestigation.getVmUser(); - userHasInvestigationListUserHasInvestigation.setVmUser(vmUser); - userHasInvestigationListUserHasInvestigation = em.merge(userHasInvestigationListUserHasInvestigation); - if (oldVmUserOfUserHasInvestigationListUserHasInvestigation != null) { - oldVmUserOfUserHasInvestigationListUserHasInvestigation.getUserHasInvestigationList().remove(userHasInvestigationListUserHasInvestigation); - oldVmUserOfUserHasInvestigationListUserHasInvestigation = em.merge(oldVmUserOfUserHasInvestigationListUserHasInvestigation); - } - } - for (UserAssigment userAssigmentListUserAssigment : vmUser.getUserAssigmentList()) { - VmUser oldVmUserOfUserAssigmentListUserAssigment = userAssigmentListUserAssigment.getVmUser(); - userAssigmentListUserAssigment.setVmUser(vmUser); - userAssigmentListUserAssigment = em.merge(userAssigmentListUserAssigment); - if (oldVmUserOfUserAssigmentListUserAssigment != null) { - oldVmUserOfUserAssigmentListUserAssigment.getUserAssigmentList().remove(userAssigmentListUserAssigment); - oldVmUserOfUserAssigmentListUserAssigment = em.merge(oldVmUserOfUserAssigmentListUserAssigment); - } - } - for (UserAssigment userAssigmentList1UserAssigment : vmUser.getUserAssigmentList1()) { - VmUser oldAssigneeIdOfUserAssigmentList1UserAssigment = userAssigmentList1UserAssigment.getAssigneeId(); - userAssigmentList1UserAssigment.setAssigneeId(vmUser); - userAssigmentList1UserAssigment = em.merge(userAssigmentList1UserAssigment); - if (oldAssigneeIdOfUserAssigmentList1UserAssigment != null) { - oldAssigneeIdOfUserAssigmentList1UserAssigment.getUserAssigmentList1().remove(userAssigmentList1UserAssigment); - oldAssigneeIdOfUserAssigmentList1UserAssigment = em.merge(oldAssigneeIdOfUserAssigmentList1UserAssigment); - } - } - for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssue : vmUser.getExecutionStepHasIssueList()) { - executionStepHasIssueListExecutionStepHasIssue.getVmUserList().add(vmUser); - executionStepHasIssueListExecutionStepHasIssue = em.merge(executionStepHasIssueListExecutionStepHasIssue); - } - for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUser : vmUser.getExecutionStepHasVmUserList()) { - VmUser oldVmUserOfExecutionStepHasVmUserListExecutionStepHasVmUser = executionStepHasVmUserListExecutionStepHasVmUser.getVmUser(); - executionStepHasVmUserListExecutionStepHasVmUser.setVmUser(vmUser); - executionStepHasVmUserListExecutionStepHasVmUser = em.merge(executionStepHasVmUserListExecutionStepHasVmUser); - if (oldVmUserOfExecutionStepHasVmUserListExecutionStepHasVmUser != null) { - oldVmUserOfExecutionStepHasVmUserListExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListExecutionStepHasVmUser); - oldVmUserOfExecutionStepHasVmUserListExecutionStepHasVmUser = em.merge(oldVmUserOfExecutionStepHasVmUserListExecutionStepHasVmUser); - } - } - for (History historyModificationListHistory : vmUser.getHistoryModificationList()) { - VmUser oldModifierIdOfHistoryModificationListHistory = historyModificationListHistory.getModifierId(); - historyModificationListHistory.setModifierId(vmUser); - historyModificationListHistory = em.merge(historyModificationListHistory); - if (oldModifierIdOfHistoryModificationListHistory != null) { - oldModifierIdOfHistoryModificationListHistory.getHistoryModificationList().remove(historyModificationListHistory); - oldModifierIdOfHistoryModificationListHistory = em.merge(oldModifierIdOfHistoryModificationListHistory); - } - } - for (Notification notificationListNotification : vmUser.getNotificationList()) { - VmUser oldTargetOfNotificationListNotification = notificationListNotification.getTargetUser(); - notificationListNotification.setTargetUser(vmUser); - notificationListNotification = em.merge(notificationListNotification); - if (oldTargetOfNotificationListNotification != null) { - oldTargetOfNotificationListNotification.getNotificationList().remove(notificationListNotification); - oldTargetOfNotificationListNotification = em.merge(oldTargetOfNotificationListNotification); - } - } - for (Notification notificationList1Notification : vmUser.getNotificationList1()) { - VmUser oldAuthorOfNotificationList1Notification = notificationList1Notification.getAuthor(); - notificationList1Notification.setAuthor(vmUser); - notificationList1Notification = em.merge(notificationList1Notification); - if (oldAuthorOfNotificationList1Notification != null) { - oldAuthorOfNotificationList1Notification.getNotificationList1().remove(notificationList1Notification); - oldAuthorOfNotificationList1Notification = em.merge(oldAuthorOfNotificationList1Notification); - } - } - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void edit(VmUser vmUser) throws IllegalOrphanException, NonexistentEntityException, Exception { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - VmUser persistentVmUser = em.find(VmUser.class, vmUser.getId()); - UserStatus userStatusIdOld = persistentVmUser.getUserStatusId(); - UserStatus userStatusIdNew = vmUser.getUserStatusId(); - List correctiveActionListOld = persistentVmUser.getCorrectiveActionList(); - List correctiveActionListNew = vmUser.getCorrectiveActionList(); - List roleListOld = persistentVmUser.getRoleList(); - List roleListNew = vmUser.getRoleList(); - List rootCauseListOld = persistentVmUser.getRootCauseList(); - List rootCauseListNew = vmUser.getRootCauseList(); - List executionStepListOld = persistentVmUser.getExecutionStepList(); - List executionStepListNew = vmUser.getExecutionStepList(); - List executionStepList1Old = persistentVmUser.getExecutionStepList1(); - List executionStepList1New = vmUser.getExecutionStepList1(); - List userTestProjectRoleListOld = persistentVmUser.getUserTestProjectRoleList(); - List userTestProjectRoleListNew = vmUser.getUserTestProjectRoleList(); - List userTestPlanRoleListOld = persistentVmUser.getUserTestPlanRoleList(); - List userTestPlanRoleListNew = vmUser.getUserTestPlanRoleList(); - List userModifiedRecordListOld = persistentVmUser.getUserModifiedRecordList(); - List userModifiedRecordListNew = vmUser.getUserModifiedRecordList(); - List userHasInvestigationListOld = persistentVmUser.getUserHasInvestigationList(); - List userHasInvestigationListNew = vmUser.getUserHasInvestigationList(); - List userAssigmentListOld = persistentVmUser.getUserAssigmentList(); - List userAssigmentListNew = vmUser.getUserAssigmentList(); - List userAssigmentList1Old = persistentVmUser.getUserAssigmentList1(); - List userAssigmentList1New = vmUser.getUserAssigmentList1(); - List executionStepHasIssueListOld = persistentVmUser.getExecutionStepHasIssueList(); - List executionStepHasIssueListNew = vmUser.getExecutionStepHasIssueList(); - List executionStepHasVmUserListOld = persistentVmUser.getExecutionStepHasVmUserList(); - List executionStepHasVmUserListNew = vmUser.getExecutionStepHasVmUserList(); - List historyModificationListOld = persistentVmUser.getHistoryModificationList(); - List historyModificationListNew = vmUser.getHistoryModificationList(); - List notificationListOld = persistentVmUser.getNotificationList(); - List notificationListNew = vmUser.getNotificationList(); - List notificationList1Old = persistentVmUser.getNotificationList1(); - List notificationList1New = vmUser.getNotificationList1(); - List illegalOrphanMessages = null; - for (UserTestProjectRole userTestProjectRoleListOldUserTestProjectRole : userTestProjectRoleListOld) { - if (!userTestProjectRoleListNew.contains(userTestProjectRoleListOldUserTestProjectRole)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserTestProjectRole " + userTestProjectRoleListOldUserTestProjectRole + " since its vmUser field is not nullable."); - } - } - for (UserTestPlanRole userTestPlanRoleListOldUserTestPlanRole : userTestPlanRoleListOld) { - if (!userTestPlanRoleListNew.contains(userTestPlanRoleListOldUserTestPlanRole)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserTestPlanRole " + userTestPlanRoleListOldUserTestPlanRole + " since its vmUser field is not nullable."); - } - } - for (UserModifiedRecord userModifiedRecordListOldUserModifiedRecord : userModifiedRecordListOld) { - if (!userModifiedRecordListNew.contains(userModifiedRecordListOldUserModifiedRecord)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserModifiedRecord " + userModifiedRecordListOldUserModifiedRecord + " since its vmUser field is not nullable."); - } - } - for (UserHasInvestigation userHasInvestigationListOldUserHasInvestigation : userHasInvestigationListOld) { - if (!userHasInvestigationListNew.contains(userHasInvestigationListOldUserHasInvestigation)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserHasInvestigation " + userHasInvestigationListOldUserHasInvestigation + " since its vmUser field is not nullable."); - } - } - for (UserAssigment userAssigmentListOldUserAssigment : userAssigmentListOld) { - if (!userAssigmentListNew.contains(userAssigmentListOldUserAssigment)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserAssigment " + userAssigmentListOldUserAssigment + " since its vmUser field is not nullable."); - } - } - for (UserAssigment userAssigmentList1OldUserAssigment : userAssigmentList1Old) { - if (!userAssigmentList1New.contains(userAssigmentList1OldUserAssigment)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain UserAssigment " + userAssigmentList1OldUserAssigment + " since its assigneeId field is not nullable."); - } - } - for (ExecutionStepHasVmUser executionStepHasVmUserListOldExecutionStepHasVmUser : executionStepHasVmUserListOld) { - if (!executionStepHasVmUserListNew.contains(executionStepHasVmUserListOldExecutionStepHasVmUser)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain ExecutionStepHasVmUser " + executionStepHasVmUserListOldExecutionStepHasVmUser + " since its vmUser field is not nullable."); - } - } - for (History historyModificationListOldHistory : historyModificationListOld) { - if (!historyModificationListNew.contains(historyModificationListOldHistory)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain History " + historyModificationListOldHistory + " since its modifierId field is not nullable."); - } - } - for (Notification notificationListOldNotification : notificationListOld) { - if (!notificationListNew.contains(notificationListOldNotification)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain Notification " + notificationListOldNotification + " since its target field is not nullable."); - } - } - for (Notification notificationList1OldNotification : notificationList1Old) { - if (!notificationList1New.contains(notificationList1OldNotification)) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("You must retain Notification " + notificationList1OldNotification + " since its author field is not nullable."); - } - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - if (userStatusIdNew != null) { - userStatusIdNew = em.getReference(userStatusIdNew.getClass(), userStatusIdNew.getId()); - vmUser.setUserStatusId(userStatusIdNew); - } - List attachedCorrectiveActionListNew = new ArrayList(); - for (CorrectiveAction correctiveActionListNewCorrectiveActionToAttach : correctiveActionListNew) { - correctiveActionListNewCorrectiveActionToAttach = em.getReference(correctiveActionListNewCorrectiveActionToAttach.getClass(), correctiveActionListNewCorrectiveActionToAttach.getId()); - attachedCorrectiveActionListNew.add(correctiveActionListNewCorrectiveActionToAttach); - } - correctiveActionListNew = attachedCorrectiveActionListNew; - vmUser.setCorrectiveActionList(correctiveActionListNew); - List attachedRoleListNew = new ArrayList(); - for (Role roleListNewRoleToAttach : roleListNew) { - roleListNewRoleToAttach = em.getReference(roleListNewRoleToAttach.getClass(), roleListNewRoleToAttach.getId()); - attachedRoleListNew.add(roleListNewRoleToAttach); - } - roleListNew = attachedRoleListNew; - vmUser.setRoleList(roleListNew); - List attachedRootCauseListNew = new ArrayList(); - for (RootCause rootCauseListNewRootCauseToAttach : rootCauseListNew) { - rootCauseListNewRootCauseToAttach = em.getReference(rootCauseListNewRootCauseToAttach.getClass(), rootCauseListNewRootCauseToAttach.getRootCausePK()); - attachedRootCauseListNew.add(rootCauseListNewRootCauseToAttach); - } - rootCauseListNew = attachedRootCauseListNew; - vmUser.setRootCauseList(rootCauseListNew); - List attachedExecutionStepListNew = new ArrayList(); - for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { - executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); - } - executionStepListNew = attachedExecutionStepListNew; - vmUser.setExecutionStepList(executionStepListNew); - List attachedExecutionStepList1New = new ArrayList(); - for (ExecutionStep executionStepList1NewExecutionStepToAttach : executionStepList1New) { - executionStepList1NewExecutionStepToAttach = em.getReference(executionStepList1NewExecutionStepToAttach.getClass(), executionStepList1NewExecutionStepToAttach.getExecutionStepPK()); - attachedExecutionStepList1New.add(executionStepList1NewExecutionStepToAttach); - } - executionStepList1New = attachedExecutionStepList1New; - vmUser.setExecutionStepList1(executionStepList1New); - List attachedUserTestProjectRoleListNew = new ArrayList(); - for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRoleToAttach : userTestProjectRoleListNew) { - userTestProjectRoleListNewUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListNewUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListNewUserTestProjectRoleToAttach.getUserTestProjectRolePK()); - attachedUserTestProjectRoleListNew.add(userTestProjectRoleListNewUserTestProjectRoleToAttach); - } - userTestProjectRoleListNew = attachedUserTestProjectRoleListNew; - vmUser.setUserTestProjectRoleList(userTestProjectRoleListNew); - List attachedUserTestPlanRoleListNew = new ArrayList(); - for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRoleToAttach : userTestPlanRoleListNew) { - userTestPlanRoleListNewUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListNewUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListNewUserTestPlanRoleToAttach.getUserTestPlanRolePK()); - attachedUserTestPlanRoleListNew.add(userTestPlanRoleListNewUserTestPlanRoleToAttach); - } - userTestPlanRoleListNew = attachedUserTestPlanRoleListNew; - vmUser.setUserTestPlanRoleList(userTestPlanRoleListNew); - List attachedUserModifiedRecordListNew = new ArrayList(); - for (UserModifiedRecord userModifiedRecordListNewUserModifiedRecordToAttach : userModifiedRecordListNew) { - userModifiedRecordListNewUserModifiedRecordToAttach = em.getReference(userModifiedRecordListNewUserModifiedRecordToAttach.getClass(), userModifiedRecordListNewUserModifiedRecordToAttach.getUserModifiedRecordPK()); - attachedUserModifiedRecordListNew.add(userModifiedRecordListNewUserModifiedRecordToAttach); - } - userModifiedRecordListNew = attachedUserModifiedRecordListNew; - vmUser.setUserModifiedRecordList(userModifiedRecordListNew); - List attachedUserHasInvestigationListNew = new ArrayList(); - for (UserHasInvestigation userHasInvestigationListNewUserHasInvestigationToAttach : userHasInvestigationListNew) { - userHasInvestigationListNewUserHasInvestigationToAttach = em.getReference(userHasInvestigationListNewUserHasInvestigationToAttach.getClass(), userHasInvestigationListNewUserHasInvestigationToAttach.getUserHasInvestigationPK()); - attachedUserHasInvestigationListNew.add(userHasInvestigationListNewUserHasInvestigationToAttach); - } - userHasInvestigationListNew = attachedUserHasInvestigationListNew; - vmUser.setUserHasInvestigationList(userHasInvestigationListNew); - List attachedUserAssigmentListNew = new ArrayList(); - for (UserAssigment userAssigmentListNewUserAssigmentToAttach : userAssigmentListNew) { - userAssigmentListNewUserAssigmentToAttach = em.getReference(userAssigmentListNewUserAssigmentToAttach.getClass(), userAssigmentListNewUserAssigmentToAttach.getUserAssigmentPK()); - attachedUserAssigmentListNew.add(userAssigmentListNewUserAssigmentToAttach); - } - userAssigmentListNew = attachedUserAssigmentListNew; - vmUser.setUserAssigmentList(userAssigmentListNew); - List attachedUserAssigmentList1New = new ArrayList(); - for (UserAssigment userAssigmentList1NewUserAssigmentToAttach : userAssigmentList1New) { - userAssigmentList1NewUserAssigmentToAttach = em.getReference(userAssigmentList1NewUserAssigmentToAttach.getClass(), userAssigmentList1NewUserAssigmentToAttach.getUserAssigmentPK()); - attachedUserAssigmentList1New.add(userAssigmentList1NewUserAssigmentToAttach); - } - userAssigmentList1New = attachedUserAssigmentList1New; - vmUser.setUserAssigmentList1(userAssigmentList1New); - List attachedExecutionStepHasIssueListNew = new ArrayList(); - for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssueToAttach : executionStepHasIssueListNew) { - executionStepHasIssueListNewExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListNewExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListNewExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); - attachedExecutionStepHasIssueListNew.add(executionStepHasIssueListNewExecutionStepHasIssueToAttach); - } - executionStepHasIssueListNew = attachedExecutionStepHasIssueListNew; - vmUser.setExecutionStepHasIssueList(executionStepHasIssueListNew); - List attachedExecutionStepHasVmUserListNew = new ArrayList(); - for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUserToAttach : executionStepHasVmUserListNew) { - executionStepHasVmUserListNewExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); - attachedExecutionStepHasVmUserListNew.add(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach); - } - executionStepHasVmUserListNew = attachedExecutionStepHasVmUserListNew; - vmUser.setExecutionStepHasVmUserList(executionStepHasVmUserListNew); - List attachedHistoryModificationListNew = new ArrayList(); - for (History historyModificationListNewHistoryToAttach : historyModificationListNew) { - historyModificationListNewHistoryToAttach = em.getReference(historyModificationListNewHistoryToAttach.getClass(), historyModificationListNewHistoryToAttach.getId()); - attachedHistoryModificationListNew.add(historyModificationListNewHistoryToAttach); - } - historyModificationListNew = attachedHistoryModificationListNew; - vmUser.setHistoryModificationList(historyModificationListNew); - List attachedNotificationListNew = new ArrayList(); - for (Notification notificationListNewNotificationToAttach : notificationListNew) { - notificationListNewNotificationToAttach = em.getReference(notificationListNewNotificationToAttach.getClass(), notificationListNewNotificationToAttach.getNotificationPK()); - attachedNotificationListNew.add(notificationListNewNotificationToAttach); - } - notificationListNew = attachedNotificationListNew; - vmUser.setNotificationList(notificationListNew); - List attachedNotificationList1New = new ArrayList(); - for (Notification notificationList1NewNotificationToAttach : notificationList1New) { - notificationList1NewNotificationToAttach = em.getReference(notificationList1NewNotificationToAttach.getClass(), notificationList1NewNotificationToAttach.getNotificationPK()); - attachedNotificationList1New.add(notificationList1NewNotificationToAttach); - } - notificationList1New = attachedNotificationList1New; - vmUser.setNotificationList1(notificationList1New); - vmUser = em.merge(vmUser); - if (userStatusIdOld != null && !userStatusIdOld.equals(userStatusIdNew)) { - userStatusIdOld.getVmUserList().remove(vmUser); - userStatusIdOld = em.merge(userStatusIdOld); - } - if (userStatusIdNew != null && !userStatusIdNew.equals(userStatusIdOld)) { - userStatusIdNew.getVmUserList().add(vmUser); - userStatusIdNew = em.merge(userStatusIdNew); - } - for (CorrectiveAction correctiveActionListOldCorrectiveAction : correctiveActionListOld) { - if (!correctiveActionListNew.contains(correctiveActionListOldCorrectiveAction)) { - correctiveActionListOldCorrectiveAction.getVmUserList().remove(vmUser); - correctiveActionListOldCorrectiveAction = em.merge(correctiveActionListOldCorrectiveAction); - } - } - for (CorrectiveAction correctiveActionListNewCorrectiveAction : correctiveActionListNew) { - if (!correctiveActionListOld.contains(correctiveActionListNewCorrectiveAction)) { - correctiveActionListNewCorrectiveAction.getVmUserList().add(vmUser); - correctiveActionListNewCorrectiveAction = em.merge(correctiveActionListNewCorrectiveAction); - } - } - for (Role roleListOldRole : roleListOld) { - if (!roleListNew.contains(roleListOldRole)) { - roleListOldRole.getVmUserList().remove(vmUser); - roleListOldRole = em.merge(roleListOldRole); - } - } - for (Role roleListNewRole : roleListNew) { - if (!roleListOld.contains(roleListNewRole)) { - roleListNewRole.getVmUserList().add(vmUser); - roleListNewRole = em.merge(roleListNewRole); - } - } - for (RootCause rootCauseListOldRootCause : rootCauseListOld) { - if (!rootCauseListNew.contains(rootCauseListOldRootCause)) { - rootCauseListOldRootCause.getVmUserList().remove(vmUser); - rootCauseListOldRootCause = em.merge(rootCauseListOldRootCause); - } - } - for (RootCause rootCauseListNewRootCause : rootCauseListNew) { - if (!rootCauseListOld.contains(rootCauseListNewRootCause)) { - rootCauseListNewRootCause.getVmUserList().add(vmUser); - rootCauseListNewRootCause = em.merge(rootCauseListNewRootCause); - } - } - for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { - if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { - executionStepListOldExecutionStep.setAssignee(null); - executionStepListOldExecutionStep = em.merge(executionStepListOldExecutionStep); - } - } - for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { - if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { - VmUser oldAssigneeOfExecutionStepListNewExecutionStep = executionStepListNewExecutionStep.getAssignee(); - executionStepListNewExecutionStep.setAssignee(vmUser); - executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); - if (oldAssigneeOfExecutionStepListNewExecutionStep != null && !oldAssigneeOfExecutionStepListNewExecutionStep.equals(vmUser)) { - oldAssigneeOfExecutionStepListNewExecutionStep.getExecutionStepList().remove(executionStepListNewExecutionStep); - oldAssigneeOfExecutionStepListNewExecutionStep = em.merge(oldAssigneeOfExecutionStepListNewExecutionStep); - } - } - } - for (ExecutionStep executionStepList1OldExecutionStep : executionStepList1Old) { - if (!executionStepList1New.contains(executionStepList1OldExecutionStep)) { - executionStepList1OldExecutionStep.setAssigner(null); - executionStepList1OldExecutionStep = em.merge(executionStepList1OldExecutionStep); - } - } - for (ExecutionStep executionStepList1NewExecutionStep : executionStepList1New) { - if (!executionStepList1Old.contains(executionStepList1NewExecutionStep)) { - VmUser oldAssignerOfExecutionStepList1NewExecutionStep = executionStepList1NewExecutionStep.getAssigner(); - executionStepList1NewExecutionStep.setAssigner(vmUser); - executionStepList1NewExecutionStep = em.merge(executionStepList1NewExecutionStep); - if (oldAssignerOfExecutionStepList1NewExecutionStep != null && !oldAssignerOfExecutionStepList1NewExecutionStep.equals(vmUser)) { - oldAssignerOfExecutionStepList1NewExecutionStep.getExecutionStepList1().remove(executionStepList1NewExecutionStep); - oldAssignerOfExecutionStepList1NewExecutionStep = em.merge(oldAssignerOfExecutionStepList1NewExecutionStep); - } - } - } - for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRole : userTestProjectRoleListNew) { - if (!userTestProjectRoleListOld.contains(userTestProjectRoleListNewUserTestProjectRole)) { - VmUser oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole = userTestProjectRoleListNewUserTestProjectRole.getVmUser(); - userTestProjectRoleListNewUserTestProjectRole.setVmUser(vmUser); - userTestProjectRoleListNewUserTestProjectRole = em.merge(userTestProjectRoleListNewUserTestProjectRole); - if (oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole != null && !oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole.equals(vmUser)) { - oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListNewUserTestProjectRole); - oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole = em.merge(oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole); - } - } - } - for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRole : userTestPlanRoleListNew) { - if (!userTestPlanRoleListOld.contains(userTestPlanRoleListNewUserTestPlanRole)) { - VmUser oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole = userTestPlanRoleListNewUserTestPlanRole.getVmUser(); - userTestPlanRoleListNewUserTestPlanRole.setVmUser(vmUser); - userTestPlanRoleListNewUserTestPlanRole = em.merge(userTestPlanRoleListNewUserTestPlanRole); - if (oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole != null && !oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole.equals(vmUser)) { - oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListNewUserTestPlanRole); - oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole = em.merge(oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole); - } - } - } - for (UserModifiedRecord userModifiedRecordListNewUserModifiedRecord : userModifiedRecordListNew) { - if (!userModifiedRecordListOld.contains(userModifiedRecordListNewUserModifiedRecord)) { - VmUser oldVmUserOfUserModifiedRecordListNewUserModifiedRecord = userModifiedRecordListNewUserModifiedRecord.getVmUser(); - userModifiedRecordListNewUserModifiedRecord.setVmUser(vmUser); - userModifiedRecordListNewUserModifiedRecord = em.merge(userModifiedRecordListNewUserModifiedRecord); - if (oldVmUserOfUserModifiedRecordListNewUserModifiedRecord != null && !oldVmUserOfUserModifiedRecordListNewUserModifiedRecord.equals(vmUser)) { - oldVmUserOfUserModifiedRecordListNewUserModifiedRecord.getUserModifiedRecordList().remove(userModifiedRecordListNewUserModifiedRecord); - oldVmUserOfUserModifiedRecordListNewUserModifiedRecord = em.merge(oldVmUserOfUserModifiedRecordListNewUserModifiedRecord); - } - } - } - for (UserHasInvestigation userHasInvestigationListNewUserHasInvestigation : userHasInvestigationListNew) { - if (!userHasInvestigationListOld.contains(userHasInvestigationListNewUserHasInvestigation)) { - VmUser oldVmUserOfUserHasInvestigationListNewUserHasInvestigation = userHasInvestigationListNewUserHasInvestigation.getVmUser(); - userHasInvestigationListNewUserHasInvestigation.setVmUser(vmUser); - userHasInvestigationListNewUserHasInvestigation = em.merge(userHasInvestigationListNewUserHasInvestigation); - if (oldVmUserOfUserHasInvestigationListNewUserHasInvestigation != null && !oldVmUserOfUserHasInvestigationListNewUserHasInvestigation.equals(vmUser)) { - oldVmUserOfUserHasInvestigationListNewUserHasInvestigation.getUserHasInvestigationList().remove(userHasInvestigationListNewUserHasInvestigation); - oldVmUserOfUserHasInvestigationListNewUserHasInvestigation = em.merge(oldVmUserOfUserHasInvestigationListNewUserHasInvestigation); - } - } - } - for (UserAssigment userAssigmentListNewUserAssigment : userAssigmentListNew) { - if (!userAssigmentListOld.contains(userAssigmentListNewUserAssigment)) { - VmUser oldVmUserOfUserAssigmentListNewUserAssigment = userAssigmentListNewUserAssigment.getVmUser(); - userAssigmentListNewUserAssigment.setVmUser(vmUser); - userAssigmentListNewUserAssigment = em.merge(userAssigmentListNewUserAssigment); - if (oldVmUserOfUserAssigmentListNewUserAssigment != null && !oldVmUserOfUserAssigmentListNewUserAssigment.equals(vmUser)) { - oldVmUserOfUserAssigmentListNewUserAssigment.getUserAssigmentList().remove(userAssigmentListNewUserAssigment); - oldVmUserOfUserAssigmentListNewUserAssigment = em.merge(oldVmUserOfUserAssigmentListNewUserAssigment); - } - } - } - for (UserAssigment userAssigmentList1NewUserAssigment : userAssigmentList1New) { - if (!userAssigmentList1Old.contains(userAssigmentList1NewUserAssigment)) { - VmUser oldAssigneeIdOfUserAssigmentList1NewUserAssigment = userAssigmentList1NewUserAssigment.getAssigneeId(); - userAssigmentList1NewUserAssigment.setAssigneeId(vmUser); - userAssigmentList1NewUserAssigment = em.merge(userAssigmentList1NewUserAssigment); - if (oldAssigneeIdOfUserAssigmentList1NewUserAssigment != null && !oldAssigneeIdOfUserAssigmentList1NewUserAssigment.equals(vmUser)) { - oldAssigneeIdOfUserAssigmentList1NewUserAssigment.getUserAssigmentList1().remove(userAssigmentList1NewUserAssigment); - oldAssigneeIdOfUserAssigmentList1NewUserAssigment = em.merge(oldAssigneeIdOfUserAssigmentList1NewUserAssigment); - } - } - } - for (ExecutionStepHasIssue executionStepHasIssueListOldExecutionStepHasIssue : executionStepHasIssueListOld) { - if (!executionStepHasIssueListNew.contains(executionStepHasIssueListOldExecutionStepHasIssue)) { - executionStepHasIssueListOldExecutionStepHasIssue.getVmUserList().remove(vmUser); - executionStepHasIssueListOldExecutionStepHasIssue = em.merge(executionStepHasIssueListOldExecutionStepHasIssue); - } - } - for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssue : executionStepHasIssueListNew) { - if (!executionStepHasIssueListOld.contains(executionStepHasIssueListNewExecutionStepHasIssue)) { - executionStepHasIssueListNewExecutionStepHasIssue.getVmUserList().add(vmUser); - executionStepHasIssueListNewExecutionStepHasIssue = em.merge(executionStepHasIssueListNewExecutionStepHasIssue); - } - } - for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUser : executionStepHasVmUserListNew) { - if (!executionStepHasVmUserListOld.contains(executionStepHasVmUserListNewExecutionStepHasVmUser)) { - VmUser oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = executionStepHasVmUserListNewExecutionStepHasVmUser.getVmUser(); - executionStepHasVmUserListNewExecutionStepHasVmUser.setVmUser(vmUser); - executionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(executionStepHasVmUserListNewExecutionStepHasVmUser); - if (oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser != null && !oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.equals(vmUser)) { - oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListNewExecutionStepHasVmUser); - oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser); - } - } - } - for (History historyModificationListNewHistory : historyModificationListNew) { - if (!historyModificationListOld.contains(historyModificationListNewHistory)) { - VmUser oldModifierIdOfHistoryModificationListNewHistory = historyModificationListNewHistory.getModifierId(); - historyModificationListNewHistory.setModifierId(vmUser); - historyModificationListNewHistory = em.merge(historyModificationListNewHistory); - if (oldModifierIdOfHistoryModificationListNewHistory != null && !oldModifierIdOfHistoryModificationListNewHistory.equals(vmUser)) { - oldModifierIdOfHistoryModificationListNewHistory.getHistoryModificationList().remove(historyModificationListNewHistory); - oldModifierIdOfHistoryModificationListNewHistory = em.merge(oldModifierIdOfHistoryModificationListNewHistory); - } - } - } - for (Notification notificationListNewNotification : notificationListNew) { - if (!notificationListOld.contains(notificationListNewNotification)) { - VmUser oldTargetOfNotificationListNewNotification = notificationListNewNotification.getTargetUser(); - notificationListNewNotification.setTargetUser(vmUser); - notificationListNewNotification = em.merge(notificationListNewNotification); - if (oldTargetOfNotificationListNewNotification != null && !oldTargetOfNotificationListNewNotification.equals(vmUser)) { - oldTargetOfNotificationListNewNotification.getNotificationList().remove(notificationListNewNotification); - oldTargetOfNotificationListNewNotification = em.merge(oldTargetOfNotificationListNewNotification); - } - } - } - for (Notification notificationList1NewNotification : notificationList1New) { - if (!notificationList1Old.contains(notificationList1NewNotification)) { - VmUser oldAuthorOfNotificationList1NewNotification = notificationList1NewNotification.getAuthor(); - notificationList1NewNotification.setAuthor(vmUser); - notificationList1NewNotification = em.merge(notificationList1NewNotification); - if (oldAuthorOfNotificationList1NewNotification != null && !oldAuthorOfNotificationList1NewNotification.equals(vmUser)) { - oldAuthorOfNotificationList1NewNotification.getNotificationList1().remove(notificationList1NewNotification); - oldAuthorOfNotificationList1NewNotification = em.merge(oldAuthorOfNotificationList1NewNotification); - } - } - } - em.getTransaction().commit(); - } - catch (Exception ex) { - String msg = ex.getLocalizedMessage(); - if (msg == null || msg.length() == 0) { - Integer id = vmUser.getId(); - if (findVmUser(id) == null) { - throw new NonexistentEntityException("The vmUser with id " + id + " no longer exists."); - } - } - throw ex; - } - finally { - if (em != null) { - em.close(); - } - } - } - - public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { - EntityManager em = null; - try { - em = getEntityManager(); - em.getTransaction().begin(); - VmUser vmUser; - try { - vmUser = em.getReference(VmUser.class, id); - vmUser.getId(); - } - catch (EntityNotFoundException enfe) { - throw new NonexistentEntityException("The vmUser with id " + id + " no longer exists.", enfe); - } - List illegalOrphanMessages = null; - List userTestProjectRoleListOrphanCheck = vmUser.getUserTestProjectRoleList(); - for (UserTestProjectRole userTestProjectRoleListOrphanCheckUserTestProjectRole : userTestProjectRoleListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserTestProjectRole " + userTestProjectRoleListOrphanCheckUserTestProjectRole + " in its userTestProjectRoleList field has a non-nullable vmUser field."); - } - List userTestPlanRoleListOrphanCheck = vmUser.getUserTestPlanRoleList(); - for (UserTestPlanRole userTestPlanRoleListOrphanCheckUserTestPlanRole : userTestPlanRoleListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserTestPlanRole " + userTestPlanRoleListOrphanCheckUserTestPlanRole + " in its userTestPlanRoleList field has a non-nullable vmUser field."); - } - List userModifiedRecordListOrphanCheck = vmUser.getUserModifiedRecordList(); - for (UserModifiedRecord userModifiedRecordListOrphanCheckUserModifiedRecord : userModifiedRecordListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserModifiedRecord " + userModifiedRecordListOrphanCheckUserModifiedRecord + " in its userModifiedRecordList field has a non-nullable vmUser field."); - } - List userHasInvestigationListOrphanCheck = vmUser.getUserHasInvestigationList(); - for (UserHasInvestigation userHasInvestigationListOrphanCheckUserHasInvestigation : userHasInvestigationListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserHasInvestigation " + userHasInvestigationListOrphanCheckUserHasInvestigation + " in its userHasInvestigationList field has a non-nullable vmUser field."); - } - List userAssigmentListOrphanCheck = vmUser.getUserAssigmentList(); - for (UserAssigment userAssigmentListOrphanCheckUserAssigment : userAssigmentListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserAssigment " + userAssigmentListOrphanCheckUserAssigment + " in its userAssigmentList field has a non-nullable vmUser field."); - } - List userAssigmentList1OrphanCheck = vmUser.getUserAssigmentList1(); - for (UserAssigment userAssigmentList1OrphanCheckUserAssigment : userAssigmentList1OrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserAssigment " + userAssigmentList1OrphanCheckUserAssigment + " in its userAssigmentList1 field has a non-nullable assigneeId field."); - } - List executionStepHasVmUserListOrphanCheck = vmUser.getExecutionStepHasVmUserList(); - for (ExecutionStepHasVmUser executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser : executionStepHasVmUserListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the ExecutionStepHasVmUser " + executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser + " in its executionStepHasVmUserList field has a non-nullable vmUser field."); - } - List historyModificationListOrphanCheck = vmUser.getHistoryModificationList(); - for (History historyModificationListOrphanCheckHistory : historyModificationListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the History " + historyModificationListOrphanCheckHistory + " in its historyModificationList field has a non-nullable modifierId field."); - } - List notificationListOrphanCheck = vmUser.getNotificationList(); - for (Notification notificationListOrphanCheckNotification : notificationListOrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the Notification " + notificationListOrphanCheckNotification + " in its notificationList field has a non-nullable target field."); - } - List notificationList1OrphanCheck = vmUser.getNotificationList1(); - for (Notification notificationList1OrphanCheckNotification : notificationList1OrphanCheck) { - if (illegalOrphanMessages == null) { - illegalOrphanMessages = new ArrayList(); - } - illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the Notification " + notificationList1OrphanCheckNotification + " in its notificationList1 field has a non-nullable author field."); - } - if (illegalOrphanMessages != null) { - throw new IllegalOrphanException(illegalOrphanMessages); - } - UserStatus userStatusId = vmUser.getUserStatusId(); - if (userStatusId != null) { - userStatusId.getVmUserList().remove(vmUser); - userStatusId = em.merge(userStatusId); - } - List correctiveActionList = vmUser.getCorrectiveActionList(); - for (CorrectiveAction correctiveActionListCorrectiveAction : correctiveActionList) { - correctiveActionListCorrectiveAction.getVmUserList().remove(vmUser); - correctiveActionListCorrectiveAction = em.merge(correctiveActionListCorrectiveAction); - } - List roleList = vmUser.getRoleList(); - for (Role roleListRole : roleList) { - roleListRole.getVmUserList().remove(vmUser); - roleListRole = em.merge(roleListRole); - } - List rootCauseList = vmUser.getRootCauseList(); - for (RootCause rootCauseListRootCause : rootCauseList) { - rootCauseListRootCause.getVmUserList().remove(vmUser); - rootCauseListRootCause = em.merge(rootCauseListRootCause); - } - List executionStepList = vmUser.getExecutionStepList(); - for (ExecutionStep executionStepListExecutionStep : executionStepList) { - executionStepListExecutionStep.setAssignee(null); - executionStepListExecutionStep = em.merge(executionStepListExecutionStep); - } - List executionStepList1 = vmUser.getExecutionStepList1(); - for (ExecutionStep executionStepList1ExecutionStep : executionStepList1) { - executionStepList1ExecutionStep.setAssigner(null); - executionStepList1ExecutionStep = em.merge(executionStepList1ExecutionStep); - } - List executionStepHasIssueList = vmUser.getExecutionStepHasIssueList(); - for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssue : executionStepHasIssueList) { - executionStepHasIssueListExecutionStepHasIssue.getVmUserList().remove(vmUser); - executionStepHasIssueListExecutionStepHasIssue = em.merge(executionStepHasIssueListExecutionStepHasIssue); - } - em.remove(vmUser); - em.getTransaction().commit(); - } - finally { - if (em != null) { - em.close(); - } - } - } - - public List findVmUserEntities() { - return findVmUserEntities(true, -1, -1); - } - - public List findVmUserEntities(int maxResults, int firstResult) { - return findVmUserEntities(false, maxResults, firstResult); - } - - private List findVmUserEntities(boolean all, int maxResults, int firstResult) { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - cq.select(cq.from(VmUser.class)); - Query q = em.createQuery(cq); - if (!all) { - q.setMaxResults(maxResults); - q.setFirstResult(firstResult); - } - return q.getResultList(); - } - finally { - em.close(); - } - } - - public VmUser findVmUser(Integer id) { - EntityManager em = getEntityManager(); - try { - return em.find(VmUser.class, id); - } - finally { - em.close(); - } - } - - public int getVmUserCount() { - EntityManager em = getEntityManager(); - try { - CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); - Root rt = cq.from(VmUser.class); - cq.select(em.getCriteriaBuilder().count(rt)); - Query q = em.createQuery(cq); - return ((Long) q.getSingleResult()).intValue(); - } - finally { - em.close(); - } - } - -} +package com.validation.manager.core.db.controller; + +import java.io.Serializable; +import javax.persistence.Query; +import javax.persistence.EntityNotFoundException; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; +import com.validation.manager.core.db.UserStatus; +import com.validation.manager.core.db.CorrectiveAction; +import java.util.ArrayList; +import java.util.List; +import com.validation.manager.core.db.Role; +import com.validation.manager.core.db.RootCause; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.UserTestProjectRole; +import com.validation.manager.core.db.UserTestPlanRole; +import com.validation.manager.core.db.UserModifiedRecord; +import com.validation.manager.core.db.UserHasInvestigation; +import com.validation.manager.core.db.UserAssigment; +import com.validation.manager.core.db.ExecutionStepHasIssue; +import com.validation.manager.core.db.ExecutionStepHasVmUser; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.Notification; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class VmUserJpaController implements Serializable { + + public VmUserJpaController(EntityManagerFactory emf) { + this.emf = emf; + } + private EntityManagerFactory emf = null; + + public EntityManager getEntityManager() { + return emf.createEntityManager(); + } + + public void create(VmUser vmUser) { + if (vmUser.getCorrectiveActionList() == null) { + vmUser.setCorrectiveActionList(new ArrayList<>()); + } + if (vmUser.getRoleList() == null) { + vmUser.setRoleList(new ArrayList<>()); + } + if (vmUser.getRootCauseList() == null) { + vmUser.setRootCauseList(new ArrayList<>()); + } + if (vmUser.getExecutionStepList() == null) { + vmUser.setExecutionStepList(new ArrayList<>()); + } + if (vmUser.getExecutionStepList1() == null) { + vmUser.setExecutionStepList1(new ArrayList<>()); + } + if (vmUser.getUserTestProjectRoleList() == null) { + vmUser.setUserTestProjectRoleList(new ArrayList<>()); + } + if (vmUser.getUserTestPlanRoleList() == null) { + vmUser.setUserTestPlanRoleList(new ArrayList<>()); + } + if (vmUser.getUserModifiedRecordList() == null) { + vmUser.setUserModifiedRecordList(new ArrayList<>()); + } + if (vmUser.getUserHasInvestigationList() == null) { + vmUser.setUserHasInvestigationList(new ArrayList<>()); + } + if (vmUser.getUserAssigmentList() == null) { + vmUser.setUserAssigmentList(new ArrayList<>()); + } + if (vmUser.getUserAssigmentList1() == null) { + vmUser.setUserAssigmentList1(new ArrayList<>()); + } + if (vmUser.getExecutionStepHasIssueList() == null) { + vmUser.setExecutionStepHasIssueList(new ArrayList<>()); + } + if (vmUser.getExecutionStepHasVmUserList() == null) { + vmUser.setExecutionStepHasVmUserList(new ArrayList<>()); + } + if (vmUser.getHistoryModificationList() == null) { + vmUser.setHistoryModificationList(new ArrayList<>()); + } + if (vmUser.getNotificationList() == null) { + vmUser.setNotificationList(new ArrayList<>()); + } + if (vmUser.getNotificationList1() == null) { + vmUser.setNotificationList1(new ArrayList<>()); + } + if (vmUser.getHistoryList() == null) { + vmUser.setHistoryList(new ArrayList<>()); + } + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + UserStatus userStatusId = vmUser.getUserStatusId(); + if (userStatusId != null) { + userStatusId = em.getReference(userStatusId.getClass(), userStatusId.getId()); + vmUser.setUserStatusId(userStatusId); + } + List attachedCorrectiveActionList = new ArrayList<>(); + for (CorrectiveAction correctiveActionListCorrectiveActionToAttach : vmUser.getCorrectiveActionList()) { + correctiveActionListCorrectiveActionToAttach = em.getReference(correctiveActionListCorrectiveActionToAttach.getClass(), correctiveActionListCorrectiveActionToAttach.getId()); + attachedCorrectiveActionList.add(correctiveActionListCorrectiveActionToAttach); + } + vmUser.setCorrectiveActionList(attachedCorrectiveActionList); + List attachedRoleList = new ArrayList<>(); + for (Role roleListRoleToAttach : vmUser.getRoleList()) { + roleListRoleToAttach = em.getReference(roleListRoleToAttach.getClass(), roleListRoleToAttach.getId()); + attachedRoleList.add(roleListRoleToAttach); + } + vmUser.setRoleList(attachedRoleList); + List attachedRootCauseList = new ArrayList<>(); + for (RootCause rootCauseListRootCauseToAttach : vmUser.getRootCauseList()) { + rootCauseListRootCauseToAttach = em.getReference(rootCauseListRootCauseToAttach.getClass(), rootCauseListRootCauseToAttach.getRootCausePK()); + attachedRootCauseList.add(rootCauseListRootCauseToAttach); + } + vmUser.setRootCauseList(attachedRootCauseList); + List attachedExecutionStepList = new ArrayList<>(); + for (ExecutionStep executionStepListExecutionStepToAttach : vmUser.getExecutionStepList()) { + executionStepListExecutionStepToAttach = em.getReference(executionStepListExecutionStepToAttach.getClass(), executionStepListExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepList.add(executionStepListExecutionStepToAttach); + } + vmUser.setExecutionStepList(attachedExecutionStepList); + List attachedExecutionStepList1 = new ArrayList<>(); + for (ExecutionStep executionStepList1ExecutionStepToAttach : vmUser.getExecutionStepList1()) { + executionStepList1ExecutionStepToAttach = em.getReference(executionStepList1ExecutionStepToAttach.getClass(), executionStepList1ExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepList1.add(executionStepList1ExecutionStepToAttach); + } + vmUser.setExecutionStepList1(attachedExecutionStepList1); + List attachedUserTestProjectRoleList = new ArrayList<>(); + for (UserTestProjectRole userTestProjectRoleListUserTestProjectRoleToAttach : vmUser.getUserTestProjectRoleList()) { + userTestProjectRoleListUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListUserTestProjectRoleToAttach.getUserTestProjectRolePK()); + attachedUserTestProjectRoleList.add(userTestProjectRoleListUserTestProjectRoleToAttach); + } + vmUser.setUserTestProjectRoleList(attachedUserTestProjectRoleList); + List attachedUserTestPlanRoleList = new ArrayList<>(); + for (UserTestPlanRole userTestPlanRoleListUserTestPlanRoleToAttach : vmUser.getUserTestPlanRoleList()) { + userTestPlanRoleListUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListUserTestPlanRoleToAttach.getUserTestPlanRolePK()); + attachedUserTestPlanRoleList.add(userTestPlanRoleListUserTestPlanRoleToAttach); + } + vmUser.setUserTestPlanRoleList(attachedUserTestPlanRoleList); + List attachedUserModifiedRecordList = new ArrayList<>(); + for (UserModifiedRecord userModifiedRecordListUserModifiedRecordToAttach : vmUser.getUserModifiedRecordList()) { + userModifiedRecordListUserModifiedRecordToAttach = em.getReference(userModifiedRecordListUserModifiedRecordToAttach.getClass(), userModifiedRecordListUserModifiedRecordToAttach.getUserModifiedRecordPK()); + attachedUserModifiedRecordList.add(userModifiedRecordListUserModifiedRecordToAttach); + } + vmUser.setUserModifiedRecordList(attachedUserModifiedRecordList); + List attachedUserHasInvestigationList = new ArrayList<>(); + for (UserHasInvestigation userHasInvestigationListUserHasInvestigationToAttach : vmUser.getUserHasInvestigationList()) { + userHasInvestigationListUserHasInvestigationToAttach = em.getReference(userHasInvestigationListUserHasInvestigationToAttach.getClass(), userHasInvestigationListUserHasInvestigationToAttach.getUserHasInvestigationPK()); + attachedUserHasInvestigationList.add(userHasInvestigationListUserHasInvestigationToAttach); + } + vmUser.setUserHasInvestigationList(attachedUserHasInvestigationList); + List attachedUserAssigmentList = new ArrayList<>(); + for (UserAssigment userAssigmentListUserAssigmentToAttach : vmUser.getUserAssigmentList()) { + userAssigmentListUserAssigmentToAttach = em.getReference(userAssigmentListUserAssigmentToAttach.getClass(), userAssigmentListUserAssigmentToAttach.getUserAssigmentPK()); + attachedUserAssigmentList.add(userAssigmentListUserAssigmentToAttach); + } + vmUser.setUserAssigmentList(attachedUserAssigmentList); + List attachedUserAssigmentList1 = new ArrayList<>(); + for (UserAssigment userAssigmentList1UserAssigmentToAttach : vmUser.getUserAssigmentList1()) { + userAssigmentList1UserAssigmentToAttach = em.getReference(userAssigmentList1UserAssigmentToAttach.getClass(), userAssigmentList1UserAssigmentToAttach.getUserAssigmentPK()); + attachedUserAssigmentList1.add(userAssigmentList1UserAssigmentToAttach); + } + vmUser.setUserAssigmentList1(attachedUserAssigmentList1); + List attachedExecutionStepHasIssueList = new ArrayList<>(); + for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssueToAttach : vmUser.getExecutionStepHasIssueList()) { + executionStepHasIssueListExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); + attachedExecutionStepHasIssueList.add(executionStepHasIssueListExecutionStepHasIssueToAttach); + } + vmUser.setExecutionStepHasIssueList(attachedExecutionStepHasIssueList); + List attachedExecutionStepHasVmUserList = new ArrayList<>(); + for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUserToAttach : vmUser.getExecutionStepHasVmUserList()) { + executionStepHasVmUserListExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); + attachedExecutionStepHasVmUserList.add(executionStepHasVmUserListExecutionStepHasVmUserToAttach); + } + vmUser.setExecutionStepHasVmUserList(attachedExecutionStepHasVmUserList); + List attachedHistoryModificationList = new ArrayList<>(); + for (History historyModificationListHistoryToAttach : vmUser.getHistoryModificationList()) { + historyModificationListHistoryToAttach = em.getReference(historyModificationListHistoryToAttach.getClass(), historyModificationListHistoryToAttach.getId()); + attachedHistoryModificationList.add(historyModificationListHistoryToAttach); + } + vmUser.setHistoryModificationList(attachedHistoryModificationList); + List attachedNotificationList = new ArrayList<>(); + for (Notification notificationListNotificationToAttach : vmUser.getNotificationList()) { + notificationListNotificationToAttach = em.getReference(notificationListNotificationToAttach.getClass(), notificationListNotificationToAttach.getNotificationPK()); + attachedNotificationList.add(notificationListNotificationToAttach); + } + vmUser.setNotificationList(attachedNotificationList); + List attachedNotificationList1 = new ArrayList<>(); + for (Notification notificationList1NotificationToAttach : vmUser.getNotificationList1()) { + notificationList1NotificationToAttach = em.getReference(notificationList1NotificationToAttach.getClass(), notificationList1NotificationToAttach.getNotificationPK()); + attachedNotificationList1.add(notificationList1NotificationToAttach); + } + vmUser.setNotificationList1(attachedNotificationList1); + List attachedHistoryList = new ArrayList<>(); + for (History historyListHistoryToAttach : vmUser.getHistoryList()) { + historyListHistoryToAttach = em.getReference(historyListHistoryToAttach.getClass(), historyListHistoryToAttach.getId()); + attachedHistoryList.add(historyListHistoryToAttach); + } + vmUser.setHistoryList(attachedHistoryList); + em.persist(vmUser); + if (userStatusId != null) { + userStatusId.getVmUserList().add(vmUser); + userStatusId = em.merge(userStatusId); + } + for (CorrectiveAction correctiveActionListCorrectiveAction : vmUser.getCorrectiveActionList()) { + correctiveActionListCorrectiveAction.getVmUserList().add(vmUser); + correctiveActionListCorrectiveAction = em.merge(correctiveActionListCorrectiveAction); + } + for (Role roleListRole : vmUser.getRoleList()) { + roleListRole.getVmUserList().add(vmUser); + roleListRole = em.merge(roleListRole); + } + for (RootCause rootCauseListRootCause : vmUser.getRootCauseList()) { + rootCauseListRootCause.getVmUserList().add(vmUser); + rootCauseListRootCause = em.merge(rootCauseListRootCause); + } + for (ExecutionStep executionStepListExecutionStep : vmUser.getExecutionStepList()) { + VmUser oldAssigneeOfExecutionStepListExecutionStep = executionStepListExecutionStep.getAssignee(); + executionStepListExecutionStep.setAssignee(vmUser); + executionStepListExecutionStep = em.merge(executionStepListExecutionStep); + if (oldAssigneeOfExecutionStepListExecutionStep != null) { + oldAssigneeOfExecutionStepListExecutionStep.getExecutionStepList().remove(executionStepListExecutionStep); + oldAssigneeOfExecutionStepListExecutionStep = em.merge(oldAssigneeOfExecutionStepListExecutionStep); + } + } + for (ExecutionStep executionStepList1ExecutionStep : vmUser.getExecutionStepList1()) { + VmUser oldAssignerOfExecutionStepList1ExecutionStep = executionStepList1ExecutionStep.getAssigner(); + executionStepList1ExecutionStep.setAssigner(vmUser); + executionStepList1ExecutionStep = em.merge(executionStepList1ExecutionStep); + if (oldAssignerOfExecutionStepList1ExecutionStep != null) { + oldAssignerOfExecutionStepList1ExecutionStep.getExecutionStepList1().remove(executionStepList1ExecutionStep); + oldAssignerOfExecutionStepList1ExecutionStep = em.merge(oldAssignerOfExecutionStepList1ExecutionStep); + } + } + for (UserTestProjectRole userTestProjectRoleListUserTestProjectRole : vmUser.getUserTestProjectRoleList()) { + VmUser oldVmUserOfUserTestProjectRoleListUserTestProjectRole = userTestProjectRoleListUserTestProjectRole.getVmUser(); + userTestProjectRoleListUserTestProjectRole.setVmUser(vmUser); + userTestProjectRoleListUserTestProjectRole = em.merge(userTestProjectRoleListUserTestProjectRole); + if (oldVmUserOfUserTestProjectRoleListUserTestProjectRole != null) { + oldVmUserOfUserTestProjectRoleListUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListUserTestProjectRole); + oldVmUserOfUserTestProjectRoleListUserTestProjectRole = em.merge(oldVmUserOfUserTestProjectRoleListUserTestProjectRole); + } + } + for (UserTestPlanRole userTestPlanRoleListUserTestPlanRole : vmUser.getUserTestPlanRoleList()) { + VmUser oldVmUserOfUserTestPlanRoleListUserTestPlanRole = userTestPlanRoleListUserTestPlanRole.getVmUser(); + userTestPlanRoleListUserTestPlanRole.setVmUser(vmUser); + userTestPlanRoleListUserTestPlanRole = em.merge(userTestPlanRoleListUserTestPlanRole); + if (oldVmUserOfUserTestPlanRoleListUserTestPlanRole != null) { + oldVmUserOfUserTestPlanRoleListUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListUserTestPlanRole); + oldVmUserOfUserTestPlanRoleListUserTestPlanRole = em.merge(oldVmUserOfUserTestPlanRoleListUserTestPlanRole); + } + } + for (UserModifiedRecord userModifiedRecordListUserModifiedRecord : vmUser.getUserModifiedRecordList()) { + VmUser oldVmUserOfUserModifiedRecordListUserModifiedRecord = userModifiedRecordListUserModifiedRecord.getVmUser(); + userModifiedRecordListUserModifiedRecord.setVmUser(vmUser); + userModifiedRecordListUserModifiedRecord = em.merge(userModifiedRecordListUserModifiedRecord); + if (oldVmUserOfUserModifiedRecordListUserModifiedRecord != null) { + oldVmUserOfUserModifiedRecordListUserModifiedRecord.getUserModifiedRecordList().remove(userModifiedRecordListUserModifiedRecord); + oldVmUserOfUserModifiedRecordListUserModifiedRecord = em.merge(oldVmUserOfUserModifiedRecordListUserModifiedRecord); + } + } + for (UserHasInvestigation userHasInvestigationListUserHasInvestigation : vmUser.getUserHasInvestigationList()) { + VmUser oldVmUserOfUserHasInvestigationListUserHasInvestigation = userHasInvestigationListUserHasInvestigation.getVmUser(); + userHasInvestigationListUserHasInvestigation.setVmUser(vmUser); + userHasInvestigationListUserHasInvestigation = em.merge(userHasInvestigationListUserHasInvestigation); + if (oldVmUserOfUserHasInvestigationListUserHasInvestigation != null) { + oldVmUserOfUserHasInvestigationListUserHasInvestigation.getUserHasInvestigationList().remove(userHasInvestigationListUserHasInvestigation); + oldVmUserOfUserHasInvestigationListUserHasInvestigation = em.merge(oldVmUserOfUserHasInvestigationListUserHasInvestigation); + } + } + for (UserAssigment userAssigmentListUserAssigment : vmUser.getUserAssigmentList()) { + VmUser oldVmUserOfUserAssigmentListUserAssigment = userAssigmentListUserAssigment.getVmUser(); + userAssigmentListUserAssigment.setVmUser(vmUser); + userAssigmentListUserAssigment = em.merge(userAssigmentListUserAssigment); + if (oldVmUserOfUserAssigmentListUserAssigment != null) { + oldVmUserOfUserAssigmentListUserAssigment.getUserAssigmentList().remove(userAssigmentListUserAssigment); + oldVmUserOfUserAssigmentListUserAssigment = em.merge(oldVmUserOfUserAssigmentListUserAssigment); + } + } + for (UserAssigment userAssigmentList1UserAssigment : vmUser.getUserAssigmentList1()) { + VmUser oldAssigneeIdOfUserAssigmentList1UserAssigment = userAssigmentList1UserAssigment.getAssigneeId(); + userAssigmentList1UserAssigment.setAssigneeId(vmUser); + userAssigmentList1UserAssigment = em.merge(userAssigmentList1UserAssigment); + if (oldAssigneeIdOfUserAssigmentList1UserAssigment != null) { + oldAssigneeIdOfUserAssigmentList1UserAssigment.getUserAssigmentList1().remove(userAssigmentList1UserAssigment); + oldAssigneeIdOfUserAssigmentList1UserAssigment = em.merge(oldAssigneeIdOfUserAssigmentList1UserAssigment); + } + } + for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssue : vmUser.getExecutionStepHasIssueList()) { + executionStepHasIssueListExecutionStepHasIssue.getVmUserList().add(vmUser); + executionStepHasIssueListExecutionStepHasIssue = em.merge(executionStepHasIssueListExecutionStepHasIssue); + } + for (ExecutionStepHasVmUser executionStepHasVmUserListExecutionStepHasVmUser : vmUser.getExecutionStepHasVmUserList()) { + VmUser oldVmUserOfExecutionStepHasVmUserListExecutionStepHasVmUser = executionStepHasVmUserListExecutionStepHasVmUser.getVmUser(); + executionStepHasVmUserListExecutionStepHasVmUser.setVmUser(vmUser); + executionStepHasVmUserListExecutionStepHasVmUser = em.merge(executionStepHasVmUserListExecutionStepHasVmUser); + if (oldVmUserOfExecutionStepHasVmUserListExecutionStepHasVmUser != null) { + oldVmUserOfExecutionStepHasVmUserListExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListExecutionStepHasVmUser); + oldVmUserOfExecutionStepHasVmUserListExecutionStepHasVmUser = em.merge(oldVmUserOfExecutionStepHasVmUserListExecutionStepHasVmUser); + } + } + for (History historyModificationListHistory : vmUser.getHistoryModificationList()) { + VmUser oldModifierIdOfHistoryModificationListHistory = historyModificationListHistory.getModifierId(); + historyModificationListHistory.setModifierId(vmUser); + historyModificationListHistory = em.merge(historyModificationListHistory); + if (oldModifierIdOfHistoryModificationListHistory != null) { + oldModifierIdOfHistoryModificationListHistory.getHistoryModificationList().remove(historyModificationListHistory); + oldModifierIdOfHistoryModificationListHistory = em.merge(oldModifierIdOfHistoryModificationListHistory); + } + } + for (Notification notificationListNotification : vmUser.getNotificationList()) { + VmUser oldTargetUserOfNotificationListNotification = notificationListNotification.getTargetUser(); + notificationListNotification.setTargetUser(vmUser); + notificationListNotification = em.merge(notificationListNotification); + if (oldTargetUserOfNotificationListNotification != null) { + oldTargetUserOfNotificationListNotification.getNotificationList().remove(notificationListNotification); + oldTargetUserOfNotificationListNotification = em.merge(oldTargetUserOfNotificationListNotification); + } + } + for (Notification notificationList1Notification : vmUser.getNotificationList1()) { + VmUser oldAuthorOfNotificationList1Notification = notificationList1Notification.getAuthor(); + notificationList1Notification.setAuthor(vmUser); + notificationList1Notification = em.merge(notificationList1Notification); + if (oldAuthorOfNotificationList1Notification != null) { + oldAuthorOfNotificationList1Notification.getNotificationList1().remove(notificationList1Notification); + oldAuthorOfNotificationList1Notification = em.merge(oldAuthorOfNotificationList1Notification); + } + } + for (History historyListHistory : vmUser.getHistoryList()) { + VmUser oldVmUserIdOfHistoryListHistory = historyListHistory.getVmUserId(); + historyListHistory.setVmUserId(vmUser); + historyListHistory = em.merge(historyListHistory); + if (oldVmUserIdOfHistoryListHistory != null) { + oldVmUserIdOfHistoryListHistory.getHistoryList().remove(historyListHistory); + oldVmUserIdOfHistoryListHistory = em.merge(oldVmUserIdOfHistoryListHistory); + } + } + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void edit(VmUser vmUser) throws IllegalOrphanException, NonexistentEntityException, Exception { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + VmUser persistentVmUser = em.find(VmUser.class, vmUser.getId()); + UserStatus userStatusIdOld = persistentVmUser.getUserStatusId(); + UserStatus userStatusIdNew = vmUser.getUserStatusId(); + List correctiveActionListOld = persistentVmUser.getCorrectiveActionList(); + List correctiveActionListNew = vmUser.getCorrectiveActionList(); + List roleListOld = persistentVmUser.getRoleList(); + List roleListNew = vmUser.getRoleList(); + List rootCauseListOld = persistentVmUser.getRootCauseList(); + List rootCauseListNew = vmUser.getRootCauseList(); + List executionStepListOld = persistentVmUser.getExecutionStepList(); + List executionStepListNew = vmUser.getExecutionStepList(); + List executionStepList1Old = persistentVmUser.getExecutionStepList1(); + List executionStepList1New = vmUser.getExecutionStepList1(); + List userTestProjectRoleListOld = persistentVmUser.getUserTestProjectRoleList(); + List userTestProjectRoleListNew = vmUser.getUserTestProjectRoleList(); + List userTestPlanRoleListOld = persistentVmUser.getUserTestPlanRoleList(); + List userTestPlanRoleListNew = vmUser.getUserTestPlanRoleList(); + List userModifiedRecordListOld = persistentVmUser.getUserModifiedRecordList(); + List userModifiedRecordListNew = vmUser.getUserModifiedRecordList(); + List userHasInvestigationListOld = persistentVmUser.getUserHasInvestigationList(); + List userHasInvestigationListNew = vmUser.getUserHasInvestigationList(); + List userAssigmentListOld = persistentVmUser.getUserAssigmentList(); + List userAssigmentListNew = vmUser.getUserAssigmentList(); + List userAssigmentList1Old = persistentVmUser.getUserAssigmentList1(); + List userAssigmentList1New = vmUser.getUserAssigmentList1(); + List executionStepHasIssueListOld = persistentVmUser.getExecutionStepHasIssueList(); + List executionStepHasIssueListNew = vmUser.getExecutionStepHasIssueList(); + List executionStepHasVmUserListOld = persistentVmUser.getExecutionStepHasVmUserList(); + List executionStepHasVmUserListNew = vmUser.getExecutionStepHasVmUserList(); + List historyModificationListOld = persistentVmUser.getHistoryModificationList(); + List historyModificationListNew = vmUser.getHistoryModificationList(); + List notificationListOld = persistentVmUser.getNotificationList(); + List notificationListNew = vmUser.getNotificationList(); + List notificationList1Old = persistentVmUser.getNotificationList1(); + List notificationList1New = vmUser.getNotificationList1(); + List historyListOld = persistentVmUser.getHistoryList(); + List historyListNew = vmUser.getHistoryList(); + List illegalOrphanMessages = null; + for (UserTestProjectRole userTestProjectRoleListOldUserTestProjectRole : userTestProjectRoleListOld) { + if (!userTestProjectRoleListNew.contains(userTestProjectRoleListOldUserTestProjectRole)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserTestProjectRole " + userTestProjectRoleListOldUserTestProjectRole + " since its vmUser field is not nullable."); + } + } + for (UserTestPlanRole userTestPlanRoleListOldUserTestPlanRole : userTestPlanRoleListOld) { + if (!userTestPlanRoleListNew.contains(userTestPlanRoleListOldUserTestPlanRole)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserTestPlanRole " + userTestPlanRoleListOldUserTestPlanRole + " since its vmUser field is not nullable."); + } + } + for (UserModifiedRecord userModifiedRecordListOldUserModifiedRecord : userModifiedRecordListOld) { + if (!userModifiedRecordListNew.contains(userModifiedRecordListOldUserModifiedRecord)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserModifiedRecord " + userModifiedRecordListOldUserModifiedRecord + " since its vmUser field is not nullable."); + } + } + for (UserHasInvestigation userHasInvestigationListOldUserHasInvestigation : userHasInvestigationListOld) { + if (!userHasInvestigationListNew.contains(userHasInvestigationListOldUserHasInvestigation)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserHasInvestigation " + userHasInvestigationListOldUserHasInvestigation + " since its vmUser field is not nullable."); + } + } + for (UserAssigment userAssigmentListOldUserAssigment : userAssigmentListOld) { + if (!userAssigmentListNew.contains(userAssigmentListOldUserAssigment)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserAssigment " + userAssigmentListOldUserAssigment + " since its vmUser field is not nullable."); + } + } + for (UserAssigment userAssigmentList1OldUserAssigment : userAssigmentList1Old) { + if (!userAssigmentList1New.contains(userAssigmentList1OldUserAssigment)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain UserAssigment " + userAssigmentList1OldUserAssigment + " since its assigneeId field is not nullable."); + } + } + for (ExecutionStepHasVmUser executionStepHasVmUserListOldExecutionStepHasVmUser : executionStepHasVmUserListOld) { + if (!executionStepHasVmUserListNew.contains(executionStepHasVmUserListOldExecutionStepHasVmUser)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain ExecutionStepHasVmUser " + executionStepHasVmUserListOldExecutionStepHasVmUser + " since its vmUser field is not nullable."); + } + } + for (History historyModificationListOldHistory : historyModificationListOld) { + if (!historyModificationListNew.contains(historyModificationListOldHistory)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain History " + historyModificationListOldHistory + " since its modifierId field is not nullable."); + } + } + for (Notification notificationListOldNotification : notificationListOld) { + if (!notificationListNew.contains(notificationListOldNotification)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain Notification " + notificationListOldNotification + " since its targetUser field is not nullable."); + } + } + for (Notification notificationList1OldNotification : notificationList1Old) { + if (!notificationList1New.contains(notificationList1OldNotification)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain Notification " + notificationList1OldNotification + " since its author field is not nullable."); + } + } + for (History historyListOldHistory : historyListOld) { + if (!historyListNew.contains(historyListOldHistory)) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("You must retain History " + historyListOldHistory + " since its vmUserId field is not nullable."); + } + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + if (userStatusIdNew != null) { + userStatusIdNew = em.getReference(userStatusIdNew.getClass(), userStatusIdNew.getId()); + vmUser.setUserStatusId(userStatusIdNew); + } + List attachedCorrectiveActionListNew = new ArrayList<>(); + for (CorrectiveAction correctiveActionListNewCorrectiveActionToAttach : correctiveActionListNew) { + correctiveActionListNewCorrectiveActionToAttach = em.getReference(correctiveActionListNewCorrectiveActionToAttach.getClass(), correctiveActionListNewCorrectiveActionToAttach.getId()); + attachedCorrectiveActionListNew.add(correctiveActionListNewCorrectiveActionToAttach); + } + correctiveActionListNew = attachedCorrectiveActionListNew; + vmUser.setCorrectiveActionList(correctiveActionListNew); + List attachedRoleListNew = new ArrayList<>(); + for (Role roleListNewRoleToAttach : roleListNew) { + roleListNewRoleToAttach = em.getReference(roleListNewRoleToAttach.getClass(), roleListNewRoleToAttach.getId()); + attachedRoleListNew.add(roleListNewRoleToAttach); + } + roleListNew = attachedRoleListNew; + vmUser.setRoleList(roleListNew); + List attachedRootCauseListNew = new ArrayList<>(); + for (RootCause rootCauseListNewRootCauseToAttach : rootCauseListNew) { + rootCauseListNewRootCauseToAttach = em.getReference(rootCauseListNewRootCauseToAttach.getClass(), rootCauseListNewRootCauseToAttach.getRootCausePK()); + attachedRootCauseListNew.add(rootCauseListNewRootCauseToAttach); + } + rootCauseListNew = attachedRootCauseListNew; + vmUser.setRootCauseList(rootCauseListNew); + List attachedExecutionStepListNew = new ArrayList<>(); + for (ExecutionStep executionStepListNewExecutionStepToAttach : executionStepListNew) { + executionStepListNewExecutionStepToAttach = em.getReference(executionStepListNewExecutionStepToAttach.getClass(), executionStepListNewExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepListNew.add(executionStepListNewExecutionStepToAttach); + } + executionStepListNew = attachedExecutionStepListNew; + vmUser.setExecutionStepList(executionStepListNew); + List attachedExecutionStepList1New = new ArrayList<>(); + for (ExecutionStep executionStepList1NewExecutionStepToAttach : executionStepList1New) { + executionStepList1NewExecutionStepToAttach = em.getReference(executionStepList1NewExecutionStepToAttach.getClass(), executionStepList1NewExecutionStepToAttach.getExecutionStepPK()); + attachedExecutionStepList1New.add(executionStepList1NewExecutionStepToAttach); + } + executionStepList1New = attachedExecutionStepList1New; + vmUser.setExecutionStepList1(executionStepList1New); + List attachedUserTestProjectRoleListNew = new ArrayList<>(); + for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRoleToAttach : userTestProjectRoleListNew) { + userTestProjectRoleListNewUserTestProjectRoleToAttach = em.getReference(userTestProjectRoleListNewUserTestProjectRoleToAttach.getClass(), userTestProjectRoleListNewUserTestProjectRoleToAttach.getUserTestProjectRolePK()); + attachedUserTestProjectRoleListNew.add(userTestProjectRoleListNewUserTestProjectRoleToAttach); + } + userTestProjectRoleListNew = attachedUserTestProjectRoleListNew; + vmUser.setUserTestProjectRoleList(userTestProjectRoleListNew); + List attachedUserTestPlanRoleListNew = new ArrayList<>(); + for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRoleToAttach : userTestPlanRoleListNew) { + userTestPlanRoleListNewUserTestPlanRoleToAttach = em.getReference(userTestPlanRoleListNewUserTestPlanRoleToAttach.getClass(), userTestPlanRoleListNewUserTestPlanRoleToAttach.getUserTestPlanRolePK()); + attachedUserTestPlanRoleListNew.add(userTestPlanRoleListNewUserTestPlanRoleToAttach); + } + userTestPlanRoleListNew = attachedUserTestPlanRoleListNew; + vmUser.setUserTestPlanRoleList(userTestPlanRoleListNew); + List attachedUserModifiedRecordListNew = new ArrayList<>(); + for (UserModifiedRecord userModifiedRecordListNewUserModifiedRecordToAttach : userModifiedRecordListNew) { + userModifiedRecordListNewUserModifiedRecordToAttach = em.getReference(userModifiedRecordListNewUserModifiedRecordToAttach.getClass(), userModifiedRecordListNewUserModifiedRecordToAttach.getUserModifiedRecordPK()); + attachedUserModifiedRecordListNew.add(userModifiedRecordListNewUserModifiedRecordToAttach); + } + userModifiedRecordListNew = attachedUserModifiedRecordListNew; + vmUser.setUserModifiedRecordList(userModifiedRecordListNew); + List attachedUserHasInvestigationListNew = new ArrayList<>(); + for (UserHasInvestigation userHasInvestigationListNewUserHasInvestigationToAttach : userHasInvestigationListNew) { + userHasInvestigationListNewUserHasInvestigationToAttach = em.getReference(userHasInvestigationListNewUserHasInvestigationToAttach.getClass(), userHasInvestigationListNewUserHasInvestigationToAttach.getUserHasInvestigationPK()); + attachedUserHasInvestigationListNew.add(userHasInvestigationListNewUserHasInvestigationToAttach); + } + userHasInvestigationListNew = attachedUserHasInvestigationListNew; + vmUser.setUserHasInvestigationList(userHasInvestigationListNew); + List attachedUserAssigmentListNew = new ArrayList<>(); + for (UserAssigment userAssigmentListNewUserAssigmentToAttach : userAssigmentListNew) { + userAssigmentListNewUserAssigmentToAttach = em.getReference(userAssigmentListNewUserAssigmentToAttach.getClass(), userAssigmentListNewUserAssigmentToAttach.getUserAssigmentPK()); + attachedUserAssigmentListNew.add(userAssigmentListNewUserAssigmentToAttach); + } + userAssigmentListNew = attachedUserAssigmentListNew; + vmUser.setUserAssigmentList(userAssigmentListNew); + List attachedUserAssigmentList1New = new ArrayList<>(); + for (UserAssigment userAssigmentList1NewUserAssigmentToAttach : userAssigmentList1New) { + userAssigmentList1NewUserAssigmentToAttach = em.getReference(userAssigmentList1NewUserAssigmentToAttach.getClass(), userAssigmentList1NewUserAssigmentToAttach.getUserAssigmentPK()); + attachedUserAssigmentList1New.add(userAssigmentList1NewUserAssigmentToAttach); + } + userAssigmentList1New = attachedUserAssigmentList1New; + vmUser.setUserAssigmentList1(userAssigmentList1New); + List attachedExecutionStepHasIssueListNew = new ArrayList<>(); + for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssueToAttach : executionStepHasIssueListNew) { + executionStepHasIssueListNewExecutionStepHasIssueToAttach = em.getReference(executionStepHasIssueListNewExecutionStepHasIssueToAttach.getClass(), executionStepHasIssueListNewExecutionStepHasIssueToAttach.getExecutionStepHasIssuePK()); + attachedExecutionStepHasIssueListNew.add(executionStepHasIssueListNewExecutionStepHasIssueToAttach); + } + executionStepHasIssueListNew = attachedExecutionStepHasIssueListNew; + vmUser.setExecutionStepHasIssueList(executionStepHasIssueListNew); + List attachedExecutionStepHasVmUserListNew = new ArrayList<>(); + for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUserToAttach : executionStepHasVmUserListNew) { + executionStepHasVmUserListNewExecutionStepHasVmUserToAttach = em.getReference(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getClass(), executionStepHasVmUserListNewExecutionStepHasVmUserToAttach.getExecutionStepHasVmUserPK()); + attachedExecutionStepHasVmUserListNew.add(executionStepHasVmUserListNewExecutionStepHasVmUserToAttach); + } + executionStepHasVmUserListNew = attachedExecutionStepHasVmUserListNew; + vmUser.setExecutionStepHasVmUserList(executionStepHasVmUserListNew); + List attachedHistoryModificationListNew = new ArrayList<>(); + for (History historyModificationListNewHistoryToAttach : historyModificationListNew) { + historyModificationListNewHistoryToAttach = em.getReference(historyModificationListNewHistoryToAttach.getClass(), historyModificationListNewHistoryToAttach.getId()); + attachedHistoryModificationListNew.add(historyModificationListNewHistoryToAttach); + } + historyModificationListNew = attachedHistoryModificationListNew; + vmUser.setHistoryModificationList(historyModificationListNew); + List attachedNotificationListNew = new ArrayList<>(); + for (Notification notificationListNewNotificationToAttach : notificationListNew) { + notificationListNewNotificationToAttach = em.getReference(notificationListNewNotificationToAttach.getClass(), notificationListNewNotificationToAttach.getNotificationPK()); + attachedNotificationListNew.add(notificationListNewNotificationToAttach); + } + notificationListNew = attachedNotificationListNew; + vmUser.setNotificationList(notificationListNew); + List attachedNotificationList1New = new ArrayList<>(); + for (Notification notificationList1NewNotificationToAttach : notificationList1New) { + notificationList1NewNotificationToAttach = em.getReference(notificationList1NewNotificationToAttach.getClass(), notificationList1NewNotificationToAttach.getNotificationPK()); + attachedNotificationList1New.add(notificationList1NewNotificationToAttach); + } + notificationList1New = attachedNotificationList1New; + vmUser.setNotificationList1(notificationList1New); + List attachedHistoryListNew = new ArrayList<>(); + for (History historyListNewHistoryToAttach : historyListNew) { + historyListNewHistoryToAttach = em.getReference(historyListNewHistoryToAttach.getClass(), historyListNewHistoryToAttach.getId()); + attachedHistoryListNew.add(historyListNewHistoryToAttach); + } + historyListNew = attachedHistoryListNew; + vmUser.setHistoryList(historyListNew); + vmUser = em.merge(vmUser); + if (userStatusIdOld != null && !userStatusIdOld.equals(userStatusIdNew)) { + userStatusIdOld.getVmUserList().remove(vmUser); + userStatusIdOld = em.merge(userStatusIdOld); + } + if (userStatusIdNew != null && !userStatusIdNew.equals(userStatusIdOld)) { + userStatusIdNew.getVmUserList().add(vmUser); + userStatusIdNew = em.merge(userStatusIdNew); + } + for (CorrectiveAction correctiveActionListOldCorrectiveAction : correctiveActionListOld) { + if (!correctiveActionListNew.contains(correctiveActionListOldCorrectiveAction)) { + correctiveActionListOldCorrectiveAction.getVmUserList().remove(vmUser); + correctiveActionListOldCorrectiveAction = em.merge(correctiveActionListOldCorrectiveAction); + } + } + for (CorrectiveAction correctiveActionListNewCorrectiveAction : correctiveActionListNew) { + if (!correctiveActionListOld.contains(correctiveActionListNewCorrectiveAction)) { + correctiveActionListNewCorrectiveAction.getVmUserList().add(vmUser); + correctiveActionListNewCorrectiveAction = em.merge(correctiveActionListNewCorrectiveAction); + } + } + for (Role roleListOldRole : roleListOld) { + if (!roleListNew.contains(roleListOldRole)) { + roleListOldRole.getVmUserList().remove(vmUser); + roleListOldRole = em.merge(roleListOldRole); + } + } + for (Role roleListNewRole : roleListNew) { + if (!roleListOld.contains(roleListNewRole)) { + roleListNewRole.getVmUserList().add(vmUser); + roleListNewRole = em.merge(roleListNewRole); + } + } + for (RootCause rootCauseListOldRootCause : rootCauseListOld) { + if (!rootCauseListNew.contains(rootCauseListOldRootCause)) { + rootCauseListOldRootCause.getVmUserList().remove(vmUser); + rootCauseListOldRootCause = em.merge(rootCauseListOldRootCause); + } + } + for (RootCause rootCauseListNewRootCause : rootCauseListNew) { + if (!rootCauseListOld.contains(rootCauseListNewRootCause)) { + rootCauseListNewRootCause.getVmUserList().add(vmUser); + rootCauseListNewRootCause = em.merge(rootCauseListNewRootCause); + } + } + for (ExecutionStep executionStepListOldExecutionStep : executionStepListOld) { + if (!executionStepListNew.contains(executionStepListOldExecutionStep)) { + executionStepListOldExecutionStep.setAssignee(null); + executionStepListOldExecutionStep = em.merge(executionStepListOldExecutionStep); + } + } + for (ExecutionStep executionStepListNewExecutionStep : executionStepListNew) { + if (!executionStepListOld.contains(executionStepListNewExecutionStep)) { + VmUser oldAssigneeOfExecutionStepListNewExecutionStep = executionStepListNewExecutionStep.getAssignee(); + executionStepListNewExecutionStep.setAssignee(vmUser); + executionStepListNewExecutionStep = em.merge(executionStepListNewExecutionStep); + if (oldAssigneeOfExecutionStepListNewExecutionStep != null && !oldAssigneeOfExecutionStepListNewExecutionStep.equals(vmUser)) { + oldAssigneeOfExecutionStepListNewExecutionStep.getExecutionStepList().remove(executionStepListNewExecutionStep); + oldAssigneeOfExecutionStepListNewExecutionStep = em.merge(oldAssigneeOfExecutionStepListNewExecutionStep); + } + } + } + for (ExecutionStep executionStepList1OldExecutionStep : executionStepList1Old) { + if (!executionStepList1New.contains(executionStepList1OldExecutionStep)) { + executionStepList1OldExecutionStep.setAssigner(null); + executionStepList1OldExecutionStep = em.merge(executionStepList1OldExecutionStep); + } + } + for (ExecutionStep executionStepList1NewExecutionStep : executionStepList1New) { + if (!executionStepList1Old.contains(executionStepList1NewExecutionStep)) { + VmUser oldAssignerOfExecutionStepList1NewExecutionStep = executionStepList1NewExecutionStep.getAssigner(); + executionStepList1NewExecutionStep.setAssigner(vmUser); + executionStepList1NewExecutionStep = em.merge(executionStepList1NewExecutionStep); + if (oldAssignerOfExecutionStepList1NewExecutionStep != null && !oldAssignerOfExecutionStepList1NewExecutionStep.equals(vmUser)) { + oldAssignerOfExecutionStepList1NewExecutionStep.getExecutionStepList1().remove(executionStepList1NewExecutionStep); + oldAssignerOfExecutionStepList1NewExecutionStep = em.merge(oldAssignerOfExecutionStepList1NewExecutionStep); + } + } + } + for (UserTestProjectRole userTestProjectRoleListNewUserTestProjectRole : userTestProjectRoleListNew) { + if (!userTestProjectRoleListOld.contains(userTestProjectRoleListNewUserTestProjectRole)) { + VmUser oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole = userTestProjectRoleListNewUserTestProjectRole.getVmUser(); + userTestProjectRoleListNewUserTestProjectRole.setVmUser(vmUser); + userTestProjectRoleListNewUserTestProjectRole = em.merge(userTestProjectRoleListNewUserTestProjectRole); + if (oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole != null && !oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole.equals(vmUser)) { + oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole.getUserTestProjectRoleList().remove(userTestProjectRoleListNewUserTestProjectRole); + oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole = em.merge(oldVmUserOfUserTestProjectRoleListNewUserTestProjectRole); + } + } + } + for (UserTestPlanRole userTestPlanRoleListNewUserTestPlanRole : userTestPlanRoleListNew) { + if (!userTestPlanRoleListOld.contains(userTestPlanRoleListNewUserTestPlanRole)) { + VmUser oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole = userTestPlanRoleListNewUserTestPlanRole.getVmUser(); + userTestPlanRoleListNewUserTestPlanRole.setVmUser(vmUser); + userTestPlanRoleListNewUserTestPlanRole = em.merge(userTestPlanRoleListNewUserTestPlanRole); + if (oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole != null && !oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole.equals(vmUser)) { + oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole.getUserTestPlanRoleList().remove(userTestPlanRoleListNewUserTestPlanRole); + oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole = em.merge(oldVmUserOfUserTestPlanRoleListNewUserTestPlanRole); + } + } + } + for (UserModifiedRecord userModifiedRecordListNewUserModifiedRecord : userModifiedRecordListNew) { + if (!userModifiedRecordListOld.contains(userModifiedRecordListNewUserModifiedRecord)) { + VmUser oldVmUserOfUserModifiedRecordListNewUserModifiedRecord = userModifiedRecordListNewUserModifiedRecord.getVmUser(); + userModifiedRecordListNewUserModifiedRecord.setVmUser(vmUser); + userModifiedRecordListNewUserModifiedRecord = em.merge(userModifiedRecordListNewUserModifiedRecord); + if (oldVmUserOfUserModifiedRecordListNewUserModifiedRecord != null && !oldVmUserOfUserModifiedRecordListNewUserModifiedRecord.equals(vmUser)) { + oldVmUserOfUserModifiedRecordListNewUserModifiedRecord.getUserModifiedRecordList().remove(userModifiedRecordListNewUserModifiedRecord); + oldVmUserOfUserModifiedRecordListNewUserModifiedRecord = em.merge(oldVmUserOfUserModifiedRecordListNewUserModifiedRecord); + } + } + } + for (UserHasInvestigation userHasInvestigationListNewUserHasInvestigation : userHasInvestigationListNew) { + if (!userHasInvestigationListOld.contains(userHasInvestigationListNewUserHasInvestigation)) { + VmUser oldVmUserOfUserHasInvestigationListNewUserHasInvestigation = userHasInvestigationListNewUserHasInvestigation.getVmUser(); + userHasInvestigationListNewUserHasInvestigation.setVmUser(vmUser); + userHasInvestigationListNewUserHasInvestigation = em.merge(userHasInvestigationListNewUserHasInvestigation); + if (oldVmUserOfUserHasInvestigationListNewUserHasInvestigation != null && !oldVmUserOfUserHasInvestigationListNewUserHasInvestigation.equals(vmUser)) { + oldVmUserOfUserHasInvestigationListNewUserHasInvestigation.getUserHasInvestigationList().remove(userHasInvestigationListNewUserHasInvestigation); + oldVmUserOfUserHasInvestigationListNewUserHasInvestigation = em.merge(oldVmUserOfUserHasInvestigationListNewUserHasInvestigation); + } + } + } + for (UserAssigment userAssigmentListNewUserAssigment : userAssigmentListNew) { + if (!userAssigmentListOld.contains(userAssigmentListNewUserAssigment)) { + VmUser oldVmUserOfUserAssigmentListNewUserAssigment = userAssigmentListNewUserAssigment.getVmUser(); + userAssigmentListNewUserAssigment.setVmUser(vmUser); + userAssigmentListNewUserAssigment = em.merge(userAssigmentListNewUserAssigment); + if (oldVmUserOfUserAssigmentListNewUserAssigment != null && !oldVmUserOfUserAssigmentListNewUserAssigment.equals(vmUser)) { + oldVmUserOfUserAssigmentListNewUserAssigment.getUserAssigmentList().remove(userAssigmentListNewUserAssigment); + oldVmUserOfUserAssigmentListNewUserAssigment = em.merge(oldVmUserOfUserAssigmentListNewUserAssigment); + } + } + } + for (UserAssigment userAssigmentList1NewUserAssigment : userAssigmentList1New) { + if (!userAssigmentList1Old.contains(userAssigmentList1NewUserAssigment)) { + VmUser oldAssigneeIdOfUserAssigmentList1NewUserAssigment = userAssigmentList1NewUserAssigment.getAssigneeId(); + userAssigmentList1NewUserAssigment.setAssigneeId(vmUser); + userAssigmentList1NewUserAssigment = em.merge(userAssigmentList1NewUserAssigment); + if (oldAssigneeIdOfUserAssigmentList1NewUserAssigment != null && !oldAssigneeIdOfUserAssigmentList1NewUserAssigment.equals(vmUser)) { + oldAssigneeIdOfUserAssigmentList1NewUserAssigment.getUserAssigmentList1().remove(userAssigmentList1NewUserAssigment); + oldAssigneeIdOfUserAssigmentList1NewUserAssigment = em.merge(oldAssigneeIdOfUserAssigmentList1NewUserAssigment); + } + } + } + for (ExecutionStepHasIssue executionStepHasIssueListOldExecutionStepHasIssue : executionStepHasIssueListOld) { + if (!executionStepHasIssueListNew.contains(executionStepHasIssueListOldExecutionStepHasIssue)) { + executionStepHasIssueListOldExecutionStepHasIssue.getVmUserList().remove(vmUser); + executionStepHasIssueListOldExecutionStepHasIssue = em.merge(executionStepHasIssueListOldExecutionStepHasIssue); + } + } + for (ExecutionStepHasIssue executionStepHasIssueListNewExecutionStepHasIssue : executionStepHasIssueListNew) { + if (!executionStepHasIssueListOld.contains(executionStepHasIssueListNewExecutionStepHasIssue)) { + executionStepHasIssueListNewExecutionStepHasIssue.getVmUserList().add(vmUser); + executionStepHasIssueListNewExecutionStepHasIssue = em.merge(executionStepHasIssueListNewExecutionStepHasIssue); + } + } + for (ExecutionStepHasVmUser executionStepHasVmUserListNewExecutionStepHasVmUser : executionStepHasVmUserListNew) { + if (!executionStepHasVmUserListOld.contains(executionStepHasVmUserListNewExecutionStepHasVmUser)) { + VmUser oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = executionStepHasVmUserListNewExecutionStepHasVmUser.getVmUser(); + executionStepHasVmUserListNewExecutionStepHasVmUser.setVmUser(vmUser); + executionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(executionStepHasVmUserListNewExecutionStepHasVmUser); + if (oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser != null && !oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.equals(vmUser)) { + oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser.getExecutionStepHasVmUserList().remove(executionStepHasVmUserListNewExecutionStepHasVmUser); + oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser = em.merge(oldVmUserOfExecutionStepHasVmUserListNewExecutionStepHasVmUser); + } + } + } + for (History historyModificationListNewHistory : historyModificationListNew) { + if (!historyModificationListOld.contains(historyModificationListNewHistory)) { + VmUser oldModifierIdOfHistoryModificationListNewHistory = historyModificationListNewHistory.getModifierId(); + historyModificationListNewHistory.setModifierId(vmUser); + historyModificationListNewHistory = em.merge(historyModificationListNewHistory); + if (oldModifierIdOfHistoryModificationListNewHistory != null && !oldModifierIdOfHistoryModificationListNewHistory.equals(vmUser)) { + oldModifierIdOfHistoryModificationListNewHistory.getHistoryModificationList().remove(historyModificationListNewHistory); + oldModifierIdOfHistoryModificationListNewHistory = em.merge(oldModifierIdOfHistoryModificationListNewHistory); + } + } + } + for (Notification notificationListNewNotification : notificationListNew) { + if (!notificationListOld.contains(notificationListNewNotification)) { + VmUser oldTargetUserOfNotificationListNewNotification = notificationListNewNotification.getTargetUser(); + notificationListNewNotification.setTargetUser(vmUser); + notificationListNewNotification = em.merge(notificationListNewNotification); + if (oldTargetUserOfNotificationListNewNotification != null && !oldTargetUserOfNotificationListNewNotification.equals(vmUser)) { + oldTargetUserOfNotificationListNewNotification.getNotificationList().remove(notificationListNewNotification); + oldTargetUserOfNotificationListNewNotification = em.merge(oldTargetUserOfNotificationListNewNotification); + } + } + } + for (Notification notificationList1NewNotification : notificationList1New) { + if (!notificationList1Old.contains(notificationList1NewNotification)) { + VmUser oldAuthorOfNotificationList1NewNotification = notificationList1NewNotification.getAuthor(); + notificationList1NewNotification.setAuthor(vmUser); + notificationList1NewNotification = em.merge(notificationList1NewNotification); + if (oldAuthorOfNotificationList1NewNotification != null && !oldAuthorOfNotificationList1NewNotification.equals(vmUser)) { + oldAuthorOfNotificationList1NewNotification.getNotificationList1().remove(notificationList1NewNotification); + oldAuthorOfNotificationList1NewNotification = em.merge(oldAuthorOfNotificationList1NewNotification); + } + } + } + for (History historyListNewHistory : historyListNew) { + if (!historyListOld.contains(historyListNewHistory)) { + VmUser oldVmUserIdOfHistoryListNewHistory = historyListNewHistory.getVmUserId(); + historyListNewHistory.setVmUserId(vmUser); + historyListNewHistory = em.merge(historyListNewHistory); + if (oldVmUserIdOfHistoryListNewHistory != null && !oldVmUserIdOfHistoryListNewHistory.equals(vmUser)) { + oldVmUserIdOfHistoryListNewHistory.getHistoryList().remove(historyListNewHistory); + oldVmUserIdOfHistoryListNewHistory = em.merge(oldVmUserIdOfHistoryListNewHistory); + } + } + } + em.getTransaction().commit(); + } + catch (Exception ex) { + String msg = ex.getLocalizedMessage(); + if (msg == null || msg.length() == 0) { + Integer id = vmUser.getId(); + if (findVmUser(id) == null) { + throw new NonexistentEntityException("The vmUser with id " + id + " no longer exists."); + } + } + throw ex; + } + finally { + if (em != null) { + em.close(); + } + } + } + + public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException { + EntityManager em = null; + try { + em = getEntityManager(); + em.getTransaction().begin(); + VmUser vmUser; + try { + vmUser = em.getReference(VmUser.class, id); + vmUser.getId(); + } + catch (EntityNotFoundException enfe) { + throw new NonexistentEntityException("The vmUser with id " + id + " no longer exists.", enfe); + } + List illegalOrphanMessages = null; + List userTestProjectRoleListOrphanCheck = vmUser.getUserTestProjectRoleList(); + for (UserTestProjectRole userTestProjectRoleListOrphanCheckUserTestProjectRole : userTestProjectRoleListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserTestProjectRole " + userTestProjectRoleListOrphanCheckUserTestProjectRole + " in its userTestProjectRoleList field has a non-nullable vmUser field."); + } + List userTestPlanRoleListOrphanCheck = vmUser.getUserTestPlanRoleList(); + for (UserTestPlanRole userTestPlanRoleListOrphanCheckUserTestPlanRole : userTestPlanRoleListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserTestPlanRole " + userTestPlanRoleListOrphanCheckUserTestPlanRole + " in its userTestPlanRoleList field has a non-nullable vmUser field."); + } + List userModifiedRecordListOrphanCheck = vmUser.getUserModifiedRecordList(); + for (UserModifiedRecord userModifiedRecordListOrphanCheckUserModifiedRecord : userModifiedRecordListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserModifiedRecord " + userModifiedRecordListOrphanCheckUserModifiedRecord + " in its userModifiedRecordList field has a non-nullable vmUser field."); + } + List userHasInvestigationListOrphanCheck = vmUser.getUserHasInvestigationList(); + for (UserHasInvestigation userHasInvestigationListOrphanCheckUserHasInvestigation : userHasInvestigationListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserHasInvestigation " + userHasInvestigationListOrphanCheckUserHasInvestigation + " in its userHasInvestigationList field has a non-nullable vmUser field."); + } + List userAssigmentListOrphanCheck = vmUser.getUserAssigmentList(); + for (UserAssigment userAssigmentListOrphanCheckUserAssigment : userAssigmentListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserAssigment " + userAssigmentListOrphanCheckUserAssigment + " in its userAssigmentList field has a non-nullable vmUser field."); + } + List userAssigmentList1OrphanCheck = vmUser.getUserAssigmentList1(); + for (UserAssigment userAssigmentList1OrphanCheckUserAssigment : userAssigmentList1OrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the UserAssigment " + userAssigmentList1OrphanCheckUserAssigment + " in its userAssigmentList1 field has a non-nullable assigneeId field."); + } + List executionStepHasVmUserListOrphanCheck = vmUser.getExecutionStepHasVmUserList(); + for (ExecutionStepHasVmUser executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser : executionStepHasVmUserListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the ExecutionStepHasVmUser " + executionStepHasVmUserListOrphanCheckExecutionStepHasVmUser + " in its executionStepHasVmUserList field has a non-nullable vmUser field."); + } + List historyModificationListOrphanCheck = vmUser.getHistoryModificationList(); + for (History historyModificationListOrphanCheckHistory : historyModificationListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the History " + historyModificationListOrphanCheckHistory + " in its historyModificationList field has a non-nullable modifierId field."); + } + List notificationListOrphanCheck = vmUser.getNotificationList(); + for (Notification notificationListOrphanCheckNotification : notificationListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the Notification " + notificationListOrphanCheckNotification + " in its notificationList field has a non-nullable targetUser field."); + } + List notificationList1OrphanCheck = vmUser.getNotificationList1(); + for (Notification notificationList1OrphanCheckNotification : notificationList1OrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the Notification " + notificationList1OrphanCheckNotification + " in its notificationList1 field has a non-nullable author field."); + } + List historyListOrphanCheck = vmUser.getHistoryList(); + for (History historyListOrphanCheckHistory : historyListOrphanCheck) { + if (illegalOrphanMessages == null) { + illegalOrphanMessages = new ArrayList<>(); + } + illegalOrphanMessages.add("This VmUser (" + vmUser + ") cannot be destroyed since the History " + historyListOrphanCheckHistory + " in its historyList field has a non-nullable vmUserId field."); + } + if (illegalOrphanMessages != null) { + throw new IllegalOrphanException(illegalOrphanMessages); + } + UserStatus userStatusId = vmUser.getUserStatusId(); + if (userStatusId != null) { + userStatusId.getVmUserList().remove(vmUser); + userStatusId = em.merge(userStatusId); + } + List correctiveActionList = vmUser.getCorrectiveActionList(); + for (CorrectiveAction correctiveActionListCorrectiveAction : correctiveActionList) { + correctiveActionListCorrectiveAction.getVmUserList().remove(vmUser); + correctiveActionListCorrectiveAction = em.merge(correctiveActionListCorrectiveAction); + } + List roleList = vmUser.getRoleList(); + for (Role roleListRole : roleList) { + roleListRole.getVmUserList().remove(vmUser); + roleListRole = em.merge(roleListRole); + } + List rootCauseList = vmUser.getRootCauseList(); + for (RootCause rootCauseListRootCause : rootCauseList) { + rootCauseListRootCause.getVmUserList().remove(vmUser); + rootCauseListRootCause = em.merge(rootCauseListRootCause); + } + List executionStepList = vmUser.getExecutionStepList(); + for (ExecutionStep executionStepListExecutionStep : executionStepList) { + executionStepListExecutionStep.setAssignee(null); + executionStepListExecutionStep = em.merge(executionStepListExecutionStep); + } + List executionStepList1 = vmUser.getExecutionStepList1(); + for (ExecutionStep executionStepList1ExecutionStep : executionStepList1) { + executionStepList1ExecutionStep.setAssigner(null); + executionStepList1ExecutionStep = em.merge(executionStepList1ExecutionStep); + } + List executionStepHasIssueList = vmUser.getExecutionStepHasIssueList(); + for (ExecutionStepHasIssue executionStepHasIssueListExecutionStepHasIssue : executionStepHasIssueList) { + executionStepHasIssueListExecutionStepHasIssue.getVmUserList().remove(vmUser); + executionStepHasIssueListExecutionStepHasIssue = em.merge(executionStepHasIssueListExecutionStepHasIssue); + } + em.remove(vmUser); + em.getTransaction().commit(); + } + finally { + if (em != null) { + em.close(); + } + } + } + + public List findVmUserEntities() { + return findVmUserEntities(true, -1, -1); + } + + public List findVmUserEntities(int maxResults, int firstResult) { + return findVmUserEntities(false, maxResults, firstResult); + } + + private List findVmUserEntities(boolean all, int maxResults, int firstResult) { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + cq.select(cq.from(VmUser.class)); + Query q = em.createQuery(cq); + if (!all) { + q.setMaxResults(maxResults); + q.setFirstResult(firstResult); + } + return q.getResultList(); + } + finally { + em.close(); + } + } + + public VmUser findVmUser(Integer id) { + EntityManager em = getEntityManager(); + try { + return em.find(VmUser.class, id); + } + finally { + em.close(); + } + } + + public int getVmUserCount() { + EntityManager em = getEntityManager(); + try { + CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); + Root rt = cq.from(VmUser.class); + cq.select(em.getCriteriaBuilder().count(rt)); + Query q = em.createQuery(cq); + return ((Long) q.getSingleResult()).intValue(); + } + finally { + em.close(); + } + } + +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/history/Login.java b/VM-Core/src/main/java/com/validation/manager/core/history/Login.java deleted file mode 100644 index 864747e9..00000000 --- a/VM-Core/src/main/java/com/validation/manager/core/history/Login.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.validation.manager.core.history; - -import java.io.Serializable; -import java.util.Date; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.MappedSuperclass; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; -import javax.validation.constraints.Min; -import javax.validation.constraints.NotNull; - -@MappedSuperclass -public abstract class Login implements Serializable { - - @Column(name = "attempts") - @Basic(optional = false) - @NotNull - @Min(value = 0) - private int attempts; - - @Column(name = "last_login") - @Basic(optional = false) - @Temporal(TemporalType.TIMESTAMP) - private Date lastModified; - - public int getAttempts() { - return this.attempts; - } - - public void setAttempts(int attempts) { - this.attempts = attempts; - } - - public Date getLastModified() { - return this.lastModified; - } - - public void setLastModified(Date lastModified) { - this.lastModified = lastModified; - } -} diff --git a/VM-Core/src/main/java/com/validation/manager/core/history/Versionable.java b/VM-Core/src/main/java/com/validation/manager/core/history/Versionable.java index 102189cc..20880cc5 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/history/Versionable.java +++ b/VM-Core/src/main/java/com/validation/manager/core/history/Versionable.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,374 +13,418 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.history; - -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.FieldType; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.HistoryField; -import com.validation.manager.core.server.core.FieldTypeServer; -import com.validation.manager.core.server.core.HistoryFieldServer; -import com.validation.manager.core.server.core.HistoryServer; -import com.validation.manager.core.server.core.VMUserServer; -import java.io.Serializable; -import java.lang.reflect.Field; -import java.nio.charset.StandardCharsets; -import java.util.ArrayList; -import java.util.Date; -import java.util.List; -import java.util.Objects; -import java.util.logging.Level; -import java.util.logging.Logger; -import javax.persistence.Basic; -import javax.persistence.Column; -import javax.persistence.DiscriminatorColumn; -import javax.persistence.Inheritance; -import javax.persistence.InheritanceType; -import javax.persistence.MappedSuperclass; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; -import org.apache.commons.lang3.reflect.FieldUtils; -import org.openide.util.Exceptions; - -@MappedSuperclass -@Inheritance(strategy = InheritanceType.JOINED) -@DiscriminatorColumn(name = "VERSIONABLE_TYPE") -public abstract class Versionable implements Comparable, - Serializable { - - private static final Logger LOG - = Logger.getLogger(Versionable.class.getSimpleName()); - - @Column(name = "majorVersion", insertable = false, updatable = false) - private Integer majorVersion = 0; - @Column(name = "midVersion", insertable = false, updatable = false) - private Integer midVersion = 0; - @Column(name = "minorVersion", insertable = false, updatable = false) - private Integer minorVersion = 1; - @Column(name = "reason", insertable = false, updatable = false) - private String reason; - @Column(name = "modifierId", insertable = false, updatable = false) - private int modifierId = -1; - @Column(name = "modificationTime", insertable = false, updatable = false) - @Temporal(TemporalType.TIMESTAMP) - private Date modificationTime; - @Column(name = "dirty") - @Basic(optional = false) - private boolean dirty = false; - - public int getModifierId() { - return modifierId; - } - - public void setModifierId(int modifierId) { - this.modifierId = modifierId; - } - - public Integer getMajorVersion() { - return this.majorVersion; - } - - public void setMajorVersion(Integer majorVersion) { - this.majorVersion = majorVersion; - } - - public Integer getMidVersion() { - return this.midVersion; - } - - public void setMidVersion(Integer midVersion) { - this.midVersion = midVersion; - } - - public Integer getMinorVersion() { - return this.minorVersion; - } - - public void setMinorVersion(Integer minorVersion) { - this.minorVersion = minorVersion; - } - - public String getReason() { - return this.reason; - } - - public void setReason(String reason) { - this.reason = reason; - } - - public Date getModificationTime() { - return this.modificationTime; - } - - public void setModificationTime(Date modificationTime) { - this.modificationTime = modificationTime; - } - - public boolean getDirty() { - return this.dirty; - } - - /** - * @param dirty the dirty to set - */ - public void setDirty(boolean dirty) { - this.dirty = dirty; - } - - /** - * Increase major version. - */ - public void increaseMajorVersion() { - setMajorVersion(getMajorVersion() + 1); - setMidVersion(0); - setMinorVersion(0); - try { - if (this instanceof EntityServer) { - EntityServer vs = (EntityServer) this; - //Copy the version changes - Versionable ao = (Versionable) vs.getEntity(); - ao.update(ao, this); - updateHistory(ao); - vs.write2DB(); - } else { - updateHistory(this); - } - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - } - - /** - * Increase major version. - */ - public void increaseMidVersion() { - setMidVersion(getMidVersion() + 1); - setMinorVersion(0); - try { - if (this instanceof EntityServer) { - EntityServer vs = (EntityServer) this; - //Copy the version changes - Versionable v = (Versionable) vs.getEntity(); - v.update(v, this); - updateHistory(v); - vs.write2DB(); - } else { - updateHistory(this); - } - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - } - - /** - * Increase minor is done by default when updating a record. - * - * @param target Target of the update. - * @param source Source of the update - */ - public void update(Versionable target, Versionable source) { - target.setDirty(source.getDirty()); - target.setMajorVersion(source.getMajorVersion()); - target.setMidVersion(source.getMidVersion()); - target.setMinorVersion(source.getMinorVersion()); - target.setModifierId(source.getModifierId()); - target.setReason(source.getReason()); - target.setModificationTime(source.getModificationTime()); - target.setHistoryList(source.getHistoryList()); - try { - target.updateHistory(); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, ex.getLocalizedMessage(), ex); - } - } - - @Override - public String toString() { - return "Version: " + getMajorVersion() + "." + getMidVersion() + "." - + getMinorVersion(); - } - - public enum CHANGE_LEVEL { - MINOR, - MODERATE, - MAJOR - } - - /** - * Get history for this entity. - * - * @return history - */ - public abstract List getHistoryList(); - - /** - * Set history for this entity - * - * @param historyList History list to set. - */ - public abstract void setHistoryList(List historyList); - - @Override - public int compareTo(Versionable o) { - if (!Objects.equals(getMajorVersion(), - o.getMajorVersion())) { - return getMajorVersion() - o.getMajorVersion(); - }//Same major version - else if (!Objects.equals(getMidVersion(), - o.getMidVersion())) { - return getMidVersion() - o.getMidVersion(); - } //Same mid version - else if (!Objects.equals(getMinorVersion(), - o.getMinorVersion())) { - return getMinorVersion() - o.getMinorVersion(); - } - //Everything the same - return 0; - } - - /** - * Add history to this entity. - * - * @param history History to add. - */ - public void addHistory(History history) { - if (getHistoryList() == null) { - setHistoryList(new ArrayList<>()); - } - getHistoryList().add(history); - } - - public static synchronized boolean auditable(Versionable v) { - History current; - boolean result = false; - if (v.getHistoryList() != null && !v.getHistoryList().isEmpty()) { - current = v.getHistoryList().get(v.getHistoryList().size() - 1); - for (HistoryField hf : current.getHistoryFieldList()) { - try { - //Compare audit field vs. the record in history. - Object o = FieldUtils.readField(FieldUtils.getField(v.getClass(), - hf.getFieldName(), true), v); - if ((o == null && !hf.getFieldValue().equals("null")) - || (!(o instanceof byte[]) && o != null - && !o.equals(hf.getFieldValue())) - || ((o instanceof byte[]) - && !new String((byte[]) o, - StandardCharsets.UTF_8) - .equals(hf.getFieldValue()))) { - result = true; - } - } - catch (SecurityException | IllegalArgumentException | IllegalAccessException ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - //As last check the version fields for changes (i.e. baselineing, etc.) - if (!result) { - result = current.getMajorVersion() < v.getMajorVersion() - || current.getMidVersion() < v.getMidVersion() - || current.getMinorVersion() < v.getMinorVersion(); - } - return result; - } - //No history so it is auditable if it has marked fields for audit. - return !FieldUtils.getFieldsListWithAnnotation(v.getClass(), - Auditable.class).isEmpty(); - } - - public void updateHistory() throws Exception { - updateHistory(this); - } - - protected void updateHistory(Versionable v) throws Exception { - //Only if an auditable field has been modified - if (auditable(v)) { - //Add history of creation - HistoryServer hs = new HistoryServer(); - if (v.getModifierId() < 0) { - try { - //By default blame system - hs.setModifierId(new VMUserServer(1).getEntity()); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - } else { - hs.setModifierId(new VMUserServer(v.getModifierId()).getEntity()); - } - - if (v.getHistoryList() != null && !v.getHistoryList().isEmpty()) { - if (v.getReason() == null - || v.getReason().equals("audit.general.creation")) { - v.setReason("audit.general.modified"); - } - History last = v.getHistoryList().get(v.getHistoryList().size() - 1); - if ((v.getMajorVersion() == 0 && v.getMidVersion() == 0) // It has default values - || last.getMajorVersion() == v.getMajorVersion() // Or it has a higher mid/major version assigned. - && last.getMidVersion() == v.getMidVersion()) { - //Make it one more than latest - hs.setMajorVersion(v.getMajorVersion()); - hs.setMidVersion(v.getMidVersion()); - hs.setMinorVersion(last.getMinorVersion() + 1); - } else { - //Copy values from object as it was forced changed. - hs.setMajorVersion(v.getMajorVersion()); - hs.setMidVersion(v.getMidVersion()); - hs.setMinorVersion(v.getMinorVersion()); - } - } else { - if (v.getReason() == null) { - v.setReason("audit.general.creation"); - } - } - hs.setReason(v.getReason()); - hs.setModificationTime(v.getModificationTime() == null - ? new Date() : v.getModificationTime()); - hs.write2DB(); - //Check the fields to be placed in history - updateFields(hs, v); - } - if (v.getHistoryList() != null && v.getHistoryList().size() > 0) { - History current = v.getHistoryList().get(v.getHistoryList().size() - 1); - //Update the version the object holds - v.setMajorVersion(current.getMajorVersion()); - v.setMidVersion(current.getMidVersion()); - v.setMinorVersion(current.getMinorVersion()); - } - } - - private synchronized void updateFields(HistoryServer hs, Versionable v) - throws IllegalArgumentException, IllegalAccessException, Exception { - for (Field field : FieldUtils.getFieldsListWithAnnotation(v.getClass(), - Auditable.class)) { - Class type = field.getType(); - String name = field.getName(); - FieldType ft = FieldTypeServer.findType(type.getSimpleName()); - if (ft == null) { - FieldTypeServer fts = new FieldTypeServer(); - fts.setTypeName(type.getSimpleName()); - fts.write2DB(); - ft = fts.getEntity(); - } - HistoryFieldServer hf - = new HistoryFieldServer(ft.getId(), hs.getId()); - hf.setFieldName(name); - hf.setFieldType(ft); - hf.setHistory(hs.getEntity()); - field.setAccessible(true); - Object value = field.get(v); - if (value instanceof byte[]) { - byte[] bytes = (byte[]) value; - value = new String(bytes, StandardCharsets.UTF_8); - } - hf.setFieldValue(value == null ? "null" : value.toString()); - hf.write2DB(); - hs.getHistoryFieldList().add(hf.getEntity()); - } - hs.write2DB(); - v.addHistory(hs.getEntity()); - } -} +package com.validation.manager.core.history; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.db.FieldType; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.HistoryField; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.VmUserJpaController; +import com.validation.manager.core.server.core.FieldTypeServer; +import com.validation.manager.core.server.core.HistoryFieldServer; +import com.validation.manager.core.server.core.HistoryServer; +import java.io.Serializable; +import java.lang.reflect.Field; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Objects; +import java.util.logging.Level; +import java.util.logging.Logger; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.DiscriminatorColumn; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.MappedSuperclass; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; +import org.apache.commons.lang3.reflect.FieldUtils; +import org.openide.util.Exceptions; + +@MappedSuperclass +@Inheritance(strategy = InheritanceType.JOINED) +@DiscriminatorColumn(name = "VERSIONABLE_TYPE") +public abstract class Versionable implements Comparable, + Serializable { + + private static final Logger LOG + = Logger.getLogger(Versionable.class.getSimpleName()); + + @Column(name = "majorVersion", insertable = false, updatable = false) + private Integer majorVersion = 0; + @Column(name = "midVersion", insertable = false, updatable = false) + private Integer midVersion = 0; + @Column(name = "minorVersion", insertable = false, updatable = false) + private Integer minorVersion = 1; + @Column(name = "reason", insertable = false, updatable = false) + private String reason; + @Column(name = "modifierId", insertable = false, updatable = false) + private int modifierId = -1; + @Column(name = "modificationTime", insertable = false, updatable = false) + @Temporal(TemporalType.TIMESTAMP) + private Date modificationTime; + @Column(name = "dirty") + @Basic(optional = false) + private boolean dirty = false; + + public int getModifierId() { + return modifierId; + } + + public void setModifierId(int modifierId) { + this.modifierId = modifierId; + } + + public Integer getMajorVersion() { + return this.majorVersion; + } + + public void setMajorVersion(Integer majorVersion) { + this.majorVersion = majorVersion; + } + + public Integer getMidVersion() { + return this.midVersion; + } + + public void setMidVersion(Integer midVersion) { + this.midVersion = midVersion; + } + + public Integer getMinorVersion() { + return this.minorVersion; + } + + public void setMinorVersion(Integer minorVersion) { + this.minorVersion = minorVersion; + } + + public String getReason() { + return this.reason; + } + + public void setReason(String reason) { + this.reason = reason; + } + + public Date getModificationTime() { + return this.modificationTime; + } + + public void setModificationTime(Date modificationTime) { + this.modificationTime = modificationTime; + } + + public boolean getDirty() { + return this.dirty; + } + + /** + * @param dirty the dirty to set + */ + public void setDirty(boolean dirty) { + this.dirty = dirty; + } + + private void updateInternalHistory() throws Exception { + if (this instanceof EntityServer) { + EntityServer vs = (EntityServer) this; + //Copy the version changes + Versionable ao = (Versionable) vs.getEntity(); + ao.update(ao, this); + updateHistory(ao); + vs.write2DB(); + } else { + updateHistory(); + try { + DataBaseManager.getEntityManagerFactory().getMetamodel() + .entity(this.getClass()); + Object key = DataBaseManager.getEntityManagerFactory() + .getPersistenceUnitUtil().getIdentifier(this); + if (key != null + && DataBaseManager.getEntityManager() + .find(this.getClass(), key) != null) { + DataBaseManager.getEntityManager().merge(this); + } + } + catch (IllegalArgumentException ex) { + LOG.log(Level.SEVERE, "Ignore if this is an Unit test!", ex); + } + } + } + + /** + * Increase major version. + */ + public void increaseMajorVersion() { + try { + updateInternalHistory(); + setMajorVersion(getMajorVersion() + 1); + setMidVersion(0); + setMinorVersion(0); + updateInternalHistory(); + } + catch (Exception ex) { + Exceptions.printStackTrace(ex); + } + } + + /** + * Increase major version. + */ + public void increaseMidVersion() { + try { + updateInternalHistory(); + setMidVersion(getMidVersion() + 1); + setMinorVersion(0); + updateInternalHistory(); + } + catch (Exception ex) { + Exceptions.printStackTrace(ex); + } + } + + /** + * Increase minor is done by default when updating a record. + * + * @param target Target of the update. + * @param source Source of the update + */ + public void update(Versionable target, Versionable source) { + target.setDirty(source.getDirty()); + target.setMajorVersion(source.getMajorVersion()); + target.setMidVersion(source.getMidVersion()); + target.setMinorVersion(source.getMinorVersion()); + target.setModifierId(source.getModifierId()); + target.setReason(source.getReason()); + target.setModificationTime(source.getModificationTime()); + target.setHistoryList(source.getHistoryList()); + try { + target.updateHistory(); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, ex.getLocalizedMessage(), ex); + } + } + + @Override + public String toString() { + return "Version: " + getMajorVersion() + "." + getMidVersion() + "." + + getMinorVersion(); + } + + public enum CHANGE_LEVEL { + MINOR, + MODERATE, + MAJOR + } + + /** + * Get history for this entity. + * + * @return history + */ + public abstract List getHistoryList(); + + /** + * Set history for this entity + * + * @param historyList History list to set. + */ + public abstract void setHistoryList(List historyList); + + @Override + public int compareTo(Versionable o) { + if (!Objects.equals(getMajorVersion(), + o.getMajorVersion())) { + return getMajorVersion() - o.getMajorVersion(); + }//Same major version + else if (!Objects.equals(getMidVersion(), + o.getMidVersion())) { + return getMidVersion() - o.getMidVersion(); + } //Same mid version + else if (!Objects.equals(getMinorVersion(), + o.getMinorVersion())) { + return getMinorVersion() - o.getMinorVersion(); + } + //Everything the same + return 0; + } + + /** + * Add history to this entity. + * + * @param history History to add. + */ + public void addHistory(History history) { + if (getHistoryList() == null) { + setHistoryList(new ArrayList<>()); + } + getHistoryList().add(history); + } + + public static boolean fieldMatchHistory(HistoryField hf, Object value) { + return !(value == null && !hf.getFieldValue().equals("null")) + || (!(value instanceof byte[]) && value != null + && !value.toString().equals(hf.getFieldValue())) + || ((value instanceof byte[]) + && !new String((byte[]) value, + StandardCharsets.UTF_8) + .equals(hf.getFieldValue())); + } + + public static synchronized boolean auditable(Versionable v) { + History current; + boolean result = false; + if (v.getHistoryList() != null && !v.getHistoryList().isEmpty()) { + current = v.getHistoryList().get(v.getHistoryList().size() - 1); + for (HistoryField hf : current.getHistoryFieldList()) { + try { + //Compare audit field vs. the record in history. + Object o = FieldUtils.readField(FieldUtils.getField(v.getClass(), + hf.getFieldName(), true), v); + if ((o == null && !hf.getFieldValue().equals("null")) + || (!(o instanceof byte[]) && o != null + && !o.toString().equals(hf.getFieldValue())) + || ((o instanceof byte[]) + && !new String((byte[]) o, + StandardCharsets.UTF_8) + .equals(hf.getFieldValue()))) { + result = true; + break; + } + } + catch (SecurityException | IllegalArgumentException | IllegalAccessException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + //As last check the version fields for changes (i.e. baselineing, etc.) + if (!result) { + result = current.getMajorVersion() < v.getMajorVersion() + || current.getMidVersion() < v.getMidVersion() + || current.getMinorVersion() < v.getMinorVersion(); + } + return result; + } + //No history so it is auditable if it has marked fields for audit. + return !FieldUtils.getFieldsListWithAnnotation(v.getClass(), + Auditable.class).isEmpty(); + } + + public void updateHistory() throws Exception { + updateHistory(this); + } + + protected void updateHistory(Versionable v) throws Exception { + //Only if an auditable field has been modified + if (auditable(v)) { + //Add history of creation + HistoryServer hs = new HistoryServer(); + VmUserJpaController c + = new VmUserJpaController(DataBaseManager.getEntityManagerFactory()); + if (v.getModifierId() <= 0) { + try { + //By default blame system + hs.setModifierId(c.findVmUser(1)); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + } + } else { + hs.setModifierId(c.findVmUser(v.getModifierId())); + } + + if (v.getHistoryList() != null && !v.getHistoryList().isEmpty()) { + if (v.getReason() == null + || v.getReason().equals("audit.general.creation")) { + v.setReason("audit.general.modified"); + } + History last = v.getHistoryList().get(v.getHistoryList().size() - 1); + if ((v.getMajorVersion() == 0 && v.getMidVersion() == 0) // It has default values + || last.getMajorVersion() == v.getMajorVersion() // Or it has a higher mid/major version assigned. + && last.getMidVersion() == v.getMidVersion()) { + //Make it one more than latest + hs.setMajorVersion(v.getMajorVersion()); + hs.setMidVersion(v.getMidVersion()); + hs.setMinorVersion(last.getMinorVersion() + 1); + } else { + //Copy values from object as it was forced changed. + hs.setMajorVersion(v.getMajorVersion()); + hs.setMidVersion(v.getMidVersion()); + hs.setMinorVersion(v.getMinorVersion()); + } + } else { + if (v.getReason() == null) { + v.setReason("audit.general.creation"); + } + } + hs.setReason(v.getReason()); + hs.setModificationTime(v.getModificationTime() == null + ? new Date() : v.getModificationTime()); + hs.write2DB(); + if (v instanceof VmUser) { + VmUser temp = (VmUser) v; + if (Objects.equals(temp.getId(), hs.getModifierId().getId())) { + if (temp.getHistoryModificationList() == null) { + temp.setHistoryModificationList(new ArrayList<>()); + } + temp.getHistoryModificationList().add(hs.getEntity()); + } + } else { + if (hs.getModifierId() != null) { + VmUser temp = hs.getModifierId(); + if (temp.getHistoryModificationList() == null) { + temp.setHistoryModificationList(new ArrayList<>()); + } + temp.getHistoryModificationList().add(hs.getEntity()); + c.edit(temp); + } + } + //Check the fields to be placed in history + updateFields(hs, v); + } + if (v.getHistoryList() != null && v.getHistoryList().size() > 0) { + History current = v.getHistoryList().get(v.getHistoryList().size() - 1); + //Update the version the object holds + v.setMajorVersion(current.getMajorVersion()); + v.setMidVersion(current.getMidVersion()); + v.setMinorVersion(current.getMinorVersion()); + } + } + + private synchronized void updateFields(HistoryServer hs, Versionable v) + throws IllegalArgumentException, IllegalAccessException, Exception { + for (Field field : FieldUtils.getFieldsListWithAnnotation(v.getClass(), + Auditable.class)) { + Class type = field.getType(); + String name = field.getName(); + FieldType ft = FieldTypeServer.findType(type.getSimpleName()); + if (ft == null) { + FieldTypeServer fts = new FieldTypeServer(); + fts.setTypeName(type.getSimpleName()); + fts.write2DB(); + ft = fts.getEntity(); + } + HistoryFieldServer hf + = new HistoryFieldServer(ft.getId(), hs.getId()); + hf.setFieldName(name); + hf.setFieldType(ft); + hf.setHistory(hs.getEntity()); + field.setAccessible(true); + Object value = field.get(v); + if (value instanceof byte[]) { + byte[] bytes = (byte[]) value; + value = new String(bytes, StandardCharsets.UTF_8); + } + hf.setFieldValue(value == null ? "null" : value.toString()); + hf.write2DB(); + hs.getHistoryFieldList().add(hf.getEntity()); + } + hs.write2DB(); + v.addHistory(hs.getEntity()); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/AttachmentServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/AttachmentServer.java index 44196078..ff19c599 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/AttachmentServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/AttachmentServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,122 +13,128 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.Attachment; -import com.validation.manager.core.db.AttachmentPK; -import com.validation.manager.core.db.controller.AttachmentJpaController; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.io.File; -import java.io.IOException; -import org.apache.commons.io.FileUtils; -import org.apache.commons.io.FilenameUtils; -import org.openide.util.Exceptions; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class AttachmentServer extends Attachment - implements EntityServer { - - public AttachmentServer(AttachmentPK attachmentPK) { - super(attachmentPK); - update(); - } - - public AttachmentServer() { - super(); - } - - @Override - public int write2DB() throws Exception { - AttachmentJpaController c - = new AttachmentJpaController(DataBaseManager.getEntityManagerFactory()); - if (getAttachmentPK() == null) { - Attachment a = new Attachment(); - update(a, this); - c.create(a); - setAttachmentPK(a.getAttachmentPK()); - update(); - } else { - Attachment a = new Attachment(); - update(a, this); - c.edit(a); - setAttachmentPK(a.getAttachmentPK()); - update(); - } - return getAttachmentPK().getId(); - } - - @Override - public Attachment getEntity() { - AttachmentJpaController c - = new AttachmentJpaController(DataBaseManager.getEntityManagerFactory()); - return c.findAttachment(getAttachmentPK()); - } - - @Override - public void update(Attachment target, Attachment source) { - target.setAttachmentPK(source.getAttachmentPK()); - target.setAttachmentType(source.getAttachmentType()); - target.setFileName(source.getFileName()); - target.setFile(source.getFile()); - target.setStringValue(source.getStringValue()); - target.setTextValue(source.getTextValue()); - target.setExecutionStepHasAttachmentList(source - .getExecutionStepHasAttachmentList()); - } - - @Override - public void update() { - update(this, getEntity()); - } - - public void addFile(File f, String fileName) { - try { - if (f != null && f.isFile() && f.exists()) { - byte[] array = FileUtils.readFileToByteArray(f); - setFile(array); - setFileName(fileName); - String ext = FilenameUtils.getExtension(getFileName()); - if (ext != null) { - //Set attachment type - setAttachmentType(AttachmentTypeServer.getTypeForExtension(ext)); - } - if (getAttachmentType() == null) { - //Set as undefined - setAttachmentType(AttachmentTypeServer.getTypeForExtension("")); - } - } - } - catch (IOException ex) { - Exceptions.printStackTrace(ex); - } - } - - public File getAttachedFile() { - File result; - try { - result = File.createTempFile("temp", "vm"); - result.deleteOnExit(); - FileUtils.writeByteArrayToFile(result, getFile()); - } - catch (IOException ex) { - Exceptions.printStackTrace(ex); - result = null; - } - return result; - } - - public static void delete(Attachment entity) - throws IllegalOrphanException, NonexistentEntityException, - Exception { - AttachmentJpaController c - = new AttachmentJpaController(DataBaseManager.getEntityManagerFactory()); - c.destroy(entity.getAttachmentPK()); - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.Attachment; +import com.validation.manager.core.db.AttachmentPK; +import com.validation.manager.core.db.controller.AttachmentJpaController; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.io.File; +import java.io.IOException; +import org.apache.commons.io.FileUtils; +import org.apache.commons.io.FilenameUtils; +import org.openide.util.Exceptions; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class AttachmentServer extends Attachment + implements EntityServer { + + public AttachmentServer(AttachmentPK attachmentPK) { + super(attachmentPK); + update(); + } + + public AttachmentServer() { + super(); + } + + @Override + public int write2DB() throws VMException { + try { + AttachmentJpaController c + = new AttachmentJpaController(DataBaseManager.getEntityManagerFactory()); + if (getAttachmentPK() == null) { + Attachment a = new Attachment(); + update(a, this); + c.create(a); + setAttachmentPK(a.getAttachmentPK()); + update(); + } else { + Attachment a = new Attachment(); + update(a, this); + c.edit(a); + setAttachmentPK(a.getAttachmentPK()); + update(); + } + } + catch (Exception ex) { + throw new VMException(ex); + } + return getAttachmentPK().getId(); + } + + @Override + public Attachment getEntity() { + AttachmentJpaController c + = new AttachmentJpaController(DataBaseManager.getEntityManagerFactory()); + return c.findAttachment(getAttachmentPK()); + } + + @Override + public void update(Attachment target, Attachment source) { + target.setAttachmentPK(source.getAttachmentPK()); + target.setAttachmentType(source.getAttachmentType()); + target.setFileName(source.getFileName()); + target.setFile(source.getFile()); + target.setStringValue(source.getStringValue()); + target.setTextValue(source.getTextValue()); + target.setExecutionStepHasAttachmentList(source + .getExecutionStepHasAttachmentList()); + } + + @Override + public void update() { + update(this, getEntity()); + } + + public void addFile(File f, String fileName) { + try { + if (f != null && f.isFile() && f.exists()) { + byte[] array = FileUtils.readFileToByteArray(f); + setFile(array); + setFileName(fileName); + String ext = FilenameUtils.getExtension(getFileName()); + if (ext != null) { + //Set attachment type + setAttachmentType(AttachmentTypeServer.getTypeForExtension(ext)); + } + if (getAttachmentType() == null) { + //Set as undefined + setAttachmentType(AttachmentTypeServer.getTypeForExtension("")); + } + } + } + catch (IOException ex) { + Exceptions.printStackTrace(ex); + } + } + + public File getAttachedFile() { + File result; + try { + result = File.createTempFile("temp", "vm"); + result.deleteOnExit(); + FileUtils.writeByteArrayToFile(result, getFile()); + } + catch (IOException ex) { + Exceptions.printStackTrace(ex); + result = null; + } + return result; + } + + public static void delete(Attachment entity) + throws IllegalOrphanException, NonexistentEntityException, + Exception { + AttachmentJpaController c + = new AttachmentJpaController(DataBaseManager.getEntityManagerFactory()); + c.destroy(entity.getAttachmentPK()); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/AttachmentTypeServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/AttachmentTypeServer.java index 855df8dc..807f0c22 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/AttachmentTypeServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/AttachmentTypeServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,69 +13,78 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.AttachmentType; -import com.validation.manager.core.db.controller.AttachmentTypeJpaController; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class AttachmentTypeServer extends AttachmentType - implements EntityServer { - - private final AttachmentTypeJpaController c - = new AttachmentTypeJpaController(DataBaseManager - .getEntityManagerFactory()); - - @Override - public int write2DB() throws Exception { - if (getId() == null) { - AttachmentType at = new AttachmentType(); - update(at, this); - c.create(at); - update(this, at); - } else { - AttachmentType at = getEntity(); - update(at, this); - c.edit(at); - update(this, at); - } - return getId(); - } - - @Override - public AttachmentType getEntity() { - return c.findAttachmentType(getId()); - } - - @Override - public void update(AttachmentType target, AttachmentType source) { - target.setAttachmentList(source.getAttachmentList()); - target.setDescription(source.getDescription()); - target.setType(source.getType()); - } - - @Override - public void update() { - update(this, getEntity()); - } - - public static AttachmentType getTypeForExtension(String ext) { - AttachmentType at = null; - //Set attachment type - for (AttachmentType type - : new AttachmentTypeJpaController(DataBaseManager - .getEntityManagerFactory()) - .findAttachmentTypeEntities()) { - if (type.getType().equals(ext)) { - at = type; - break; - } - } - return at; - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.db.AttachmentType; +import com.validation.manager.core.db.controller.AttachmentTypeJpaController; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class AttachmentTypeServer extends AttachmentType + implements EntityServer { + + private final AttachmentTypeJpaController c + = new AttachmentTypeJpaController(DataBaseManager + .getEntityManagerFactory()); + + public AttachmentTypeServer(String type) { + super(type); + } + + public AttachmentTypeServer(int id) { + setId(id); + update(); + } + + @Override + public int write2DB() throws Exception { + if (getId() == null) { + AttachmentType at = new AttachmentType(); + update(at, this); + c.create(at); + update(this, at); + } else { + AttachmentType at = getEntity(); + update(at, this); + c.edit(at); + update(this, at); + } + return getId(); + } + + @Override + public AttachmentType getEntity() { + return c.findAttachmentType(getId()); + } + + @Override + public void update(AttachmentType target, AttachmentType source) { + target.setAttachmentList(source.getAttachmentList()); + target.setDescription(source.getDescription()); + target.setType(source.getType()); + } + + @Override + public void update() { + update(this, getEntity()); + } + + public static AttachmentType getTypeForExtension(String ext) { + AttachmentType at = null; + //Set attachment type + for (AttachmentType type + : new AttachmentTypeJpaController(DataBaseManager + .getEntityManagerFactory()) + .findAttachmentTypeEntities()) { + if (type.getType().equals(ext)) { + at = type; + break; + } + } + return at; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/ExecutionResultServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/ExecutionResultServer.java index 3b69b1fa..d08bdbed 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/ExecutionResultServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/ExecutionResultServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,74 +13,83 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.ExecutionResult; -import com.validation.manager.core.db.controller.ExecutionResultJpaController; -import java.util.List; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class ExecutionResultServer extends ExecutionResult - implements EntityServer { - - @Override - public int write2DB() throws Exception { - ExecutionResultJpaController c - = new ExecutionResultJpaController(DataBaseManager - .getEntityManagerFactory()); - if (getId() == null) { - ExecutionResult r = new ExecutionResult(); - update(r, this); - c.create(r); - setId(r.getId()); - update(); - } else { - ExecutionResult r = getEntity(); - update(r, this); - c.create(r); - setId(r.getId()); - update(); - } - return getId(); - } - - @Override - public ExecutionResult getEntity() { - return new ExecutionResultJpaController(DataBaseManager - .getEntityManagerFactory()).findExecutionResult(getId()); - } - - @Override - public void update(ExecutionResult target, ExecutionResult source) { - target.setExecutionStepList(source.getExecutionStepList()); - target.setId(source.getId()); - target.setResultName(source.getResultName()); - } - - @Override - public void update() { - update(this, getEntity()); - } - - public static ExecutionResult getResult(String result) { - PARAMETERS.clear(); - PARAMETERS.put("resultName", result); - List r = DataBaseManager.namedQuery("ExecutionResult.findByResultName", - PARAMETERS); - if (r.isEmpty()) { - return null; - } else { - return (ExecutionResult) r.get(0); - } - } - - public static List getResults() { - return new ExecutionResultJpaController(DataBaseManager - .getEntityManagerFactory()).findExecutionResultEntities(); - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.db.ExecutionResult; +import com.validation.manager.core.db.controller.ExecutionResultJpaController; +import java.util.List; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ExecutionResultServer extends ExecutionResult + implements EntityServer { + + public ExecutionResultServer(String resultName) { + super(resultName); + } + + public ExecutionResultServer(int id) { + setId(id); + update(); + } + + @Override + public int write2DB() throws Exception { + ExecutionResultJpaController c + = new ExecutionResultJpaController(DataBaseManager + .getEntityManagerFactory()); + if (getId() == null) { + ExecutionResult r = new ExecutionResult(); + update(r, this); + c.create(r); + setId(r.getId()); + update(); + } else { + ExecutionResult r = getEntity(); + update(r, this); + c.edit(r); + setId(r.getId()); + update(); + } + return getId(); + } + + @Override + public ExecutionResult getEntity() { + return new ExecutionResultJpaController(DataBaseManager + .getEntityManagerFactory()).findExecutionResult(getId()); + } + + @Override + public void update(ExecutionResult target, ExecutionResult source) { + target.setExecutionStepList(source.getExecutionStepList()); + target.setId(source.getId()); + target.setResultName(source.getResultName()); + } + + @Override + public void update() { + update(this, getEntity()); + } + + public static ExecutionResult getResult(String result) { + PARAMETERS.clear(); + PARAMETERS.put("resultName", result); + List r = DataBaseManager.namedQuery("ExecutionResult.findByResultName", + PARAMETERS); + if (r.isEmpty()) { + return null; + } else { + return (ExecutionResult) r.get(0); + } + } + + public static List getResults() { + return new ExecutionResultJpaController(DataBaseManager + .getEntityManagerFactory()).findExecutionResultEntities(); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/ExecutionStepServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/ExecutionStepServer.java index 1d121528..7ee885de 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/ExecutionStepServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/ExecutionStepServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,170 +13,176 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.Attachment; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.ExecutionStepHasAttachment; -import com.validation.manager.core.db.ExecutionStepHasIssue; -import com.validation.manager.core.db.ExecutionStepPK; -import com.validation.manager.core.db.Issue; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.ExecutionStepHasAttachmentJpaController; -import com.validation.manager.core.db.controller.ExecutionStepHasIssueJpaController; -import com.validation.manager.core.db.controller.ExecutionStepJpaController; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.Date; -import org.openide.util.Exceptions; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class ExecutionStepServer extends ExecutionStep - implements EntityServer { - - private final ExecutionStepJpaController c - = new ExecutionStepJpaController(DataBaseManager - .getEntityManagerFactory()); - - public ExecutionStepServer(ExecutionStep es) { - super(es.getExecutionStepPK()); - update(); - } - - public ExecutionStepServer(ExecutionStepPK pk) { - super(pk); - update(); - } - - @Override - public int write2DB() throws Exception { - if (getExecutionStepPK() == null) { - ExecutionStep es = new ExecutionStep(); - update(es, this); - c.create(es); - setExecutionStepPK(es.getExecutionStepPK()); - update(); - } else { - ExecutionStep es = getEntity(); - update(es, this); - c.edit(es); - update(); - } - return getExecutionStepPK().getTestCaseExecutionId(); - } - - @Override - public ExecutionStep getEntity() { - return c.findExecutionStep(getExecutionStepPK()); - } - - @Override - public void update(ExecutionStep target, ExecutionStep source) { - if (target.getExecutionStepHasAttachmentList() == null) { - target.setExecutionStepHasAttachmentList(new ArrayList<>()); - } - target.setAssignedTime(source.getAssignedTime()); - target.setComment(source.getComment()); - target.setExecutionEnd(source.getExecutionEnd()); - target.setExecutionStart(source.getExecutionStart()); - target.setExecutionStepHasAttachmentList(source - .getExecutionStepHasAttachmentList()); - target.setExecutionTime(source.getExecutionTime()); - target.setResultId(source.getResultId()); - target.setStep(source.getStep()); - target.setTestCaseExecution(source.getTestCaseExecution()); - target.setAssignee(source.getAssignee()); - target.setAssigner(source.getAssigner()); - target.setLocked(source.getLocked()); - target.setExecutionStepHasIssueList(source.getExecutionStepHasIssueList()); - target.setReviewed(source.getReviewed()); - target.setReviewDate(source.getReviewDate()); - target.setHistoryList(source.getHistoryList()); - target.setStepHistory(source.getStepHistory()); - } - - @Override - public void update() { - update(this, getEntity()); - } - - public void assignUser(VmUser assignee, VmUser assigner) { - try { - setAssignee(assignee); - setAssigner(assigner); - setAssignedTime(new Date()); - write2DB(); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - } - - public void addAttachment(AttachmentServer attachment) throws Exception { - ExecutionStepHasAttachment esha = new ExecutionStepHasAttachment(); - ExecutionStepHasAttachmentJpaController controller - = new ExecutionStepHasAttachmentJpaController(DataBaseManager - .getEntityManagerFactory()); - esha.setAttachment(attachment.getEntity()); - esha.setExecutionStep(getEntity()); - esha.setCreationTime(new Date()); - controller.create(esha); - getExecutionStepHasAttachmentList().add(esha); - write2DB(); - update(); - } - - public void addIssue(IssueServer issue, VMUserServer user) throws Exception { - ExecutionStepHasIssue eshi = new ExecutionStepHasIssue(); - ExecutionStepHasIssueJpaController controller - = new ExecutionStepHasIssueJpaController(DataBaseManager - .getEntityManagerFactory()); - eshi.setIssue(issue.getEntity()); - eshi.setExecutionStep(getEntity()); - eshi.setVmUserList(new ArrayList<>()); - eshi.getVmUserList().add(user.getEntity()); - controller.create(eshi); - getExecutionStepHasIssueList().add(eshi); - write2DB(); - update(); - } - - public void removeAttachment(Attachment attachment) throws Exception { - ExecutionStepHasAttachment toRemove = null; - for (ExecutionStepHasAttachment esha : getExecutionStepHasAttachmentList()) { - if (esha.getAttachment().getAttachmentPK().getId() - == attachment.getAttachmentPK().getId()) { - toRemove = esha; - break; - } - } - if (toRemove != null) { - new ExecutionStepHasAttachmentJpaController(DataBaseManager - .getEntityManagerFactory()).destroy(toRemove - .getExecutionStepHasAttachmentPK()); - update(); - } - } - - public void removeIssue(Issue issue) throws NonexistentEntityException { - ExecutionStepHasIssue toRemove = null; - for (ExecutionStepHasIssue eshi : getExecutionStepHasIssueList()) { - if (eshi.getIssue().getIssuePK().getId() - == issue.getIssuePK().getId()) { - toRemove = eshi; - break; - } - } - if (toRemove != null) { - new ExecutionStepHasIssueJpaController(DataBaseManager - .getEntityManagerFactory()).destroy(toRemove - .getExecutionStepHasIssuePK()); - update(); - } - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.Attachment; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.ExecutionStepHasAttachment; +import com.validation.manager.core.db.ExecutionStepHasIssue; +import com.validation.manager.core.db.ExecutionStepPK; +import com.validation.manager.core.db.Issue; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.ExecutionStepHasAttachmentJpaController; +import com.validation.manager.core.db.controller.ExecutionStepHasIssueJpaController; +import com.validation.manager.core.db.controller.ExecutionStepJpaController; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.Date; +import org.openide.util.Exceptions; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class ExecutionStepServer extends ExecutionStep + implements EntityServer { + + private final ExecutionStepJpaController c + = new ExecutionStepJpaController(DataBaseManager + .getEntityManagerFactory()); + + public ExecutionStepServer(ExecutionStep es) { + super(es.getExecutionStepPK()); + update(); + } + + public ExecutionStepServer(ExecutionStepPK pk) { + super(pk); + update(); + } + + @Override + public int write2DB() throws VMException { + try { + if (getExecutionStepPK() == null) { + ExecutionStep es = new ExecutionStep(); + update(es, this); + c.create(es); + setExecutionStepPK(es.getExecutionStepPK()); + update(); + } else { + ExecutionStep es = getEntity(); + update(es, this); + c.edit(es); + update(); + } + } + catch (Exception ex) { + throw new VMException(ex); + } + return getExecutionStepPK().getTestCaseExecutionId(); + } + + @Override + public ExecutionStep getEntity() { + return c.findExecutionStep(getExecutionStepPK()); + } + + @Override + public void update(ExecutionStep target, ExecutionStep source) { + if (target.getExecutionStepHasAttachmentList() == null) { + target.setExecutionStepHasAttachmentList(new ArrayList<>()); + } + target.setAssignedTime(source.getAssignedTime()); + target.setComment(source.getComment()); + target.setExecutionEnd(source.getExecutionEnd()); + target.setExecutionStart(source.getExecutionStart()); + target.setExecutionStepHasAttachmentList(source + .getExecutionStepHasAttachmentList()); + target.setExecutionTime(source.getExecutionTime()); + target.setResultId(source.getResultId()); + target.setStep(source.getStep()); + target.setTestCaseExecution(source.getTestCaseExecution()); + target.setAssignee(source.getAssignee()); + target.setAssigner(source.getAssigner()); + target.setLocked(source.getLocked()); + target.setExecutionStepHasIssueList(source.getExecutionStepHasIssueList()); + target.setReviewed(source.getReviewed()); + target.setReviewDate(source.getReviewDate()); + target.setHistoryList(source.getHistoryList()); + target.setStepHistory(source.getStepHistory()); + } + + @Override + public void update() { + update(this, getEntity()); + } + + public void assignUser(VmUser assignee, VmUser assigner) { + try { + setAssignee(assignee); + setAssigner(assigner); + setAssignedTime(new Date()); + write2DB(); + } + catch (VMException ex) { + Exceptions.printStackTrace(ex); + } + } + + public void addAttachment(AttachmentServer attachment) throws Exception { + ExecutionStepHasAttachment esha = new ExecutionStepHasAttachment(); + ExecutionStepHasAttachmentJpaController controller + = new ExecutionStepHasAttachmentJpaController(DataBaseManager + .getEntityManagerFactory()); + esha.setAttachment(attachment.getEntity()); + esha.setExecutionStep(getEntity()); + esha.setCreationTime(new Date()); + controller.create(esha); + getExecutionStepHasAttachmentList().add(esha); + write2DB(); + update(); + } + + public void addIssue(IssueServer issue, VMUserServer user) throws Exception { + ExecutionStepHasIssue eshi = new ExecutionStepHasIssue(); + ExecutionStepHasIssueJpaController controller + = new ExecutionStepHasIssueJpaController(DataBaseManager + .getEntityManagerFactory()); + eshi.setIssue(issue.getEntity()); + eshi.setExecutionStep(getEntity()); + eshi.setVmUserList(new ArrayList<>()); + eshi.getVmUserList().add(user.getEntity()); + controller.create(eshi); + getExecutionStepHasIssueList().add(eshi); + write2DB(); + update(); + } + + public void removeAttachment(Attachment attachment) throws Exception { + ExecutionStepHasAttachment toRemove = null; + for (ExecutionStepHasAttachment esha : getExecutionStepHasAttachmentList()) { + if (esha.getAttachment().getAttachmentPK().getId() + == attachment.getAttachmentPK().getId()) { + toRemove = esha; + break; + } + } + if (toRemove != null) { + new ExecutionStepHasAttachmentJpaController(DataBaseManager + .getEntityManagerFactory()).destroy(toRemove + .getExecutionStepHasAttachmentPK()); + update(); + } + } + + public void removeIssue(Issue issue) throws NonexistentEntityException { + ExecutionStepHasIssue toRemove = null; + for (ExecutionStepHasIssue eshi : getExecutionStepHasIssueList()) { + if (eshi.getIssue().getIssuePK().getId() + == issue.getIssuePK().getId()) { + toRemove = eshi; + break; + } + } + if (toRemove != null) { + new ExecutionStepHasIssueJpaController(DataBaseManager + .getEntityManagerFactory()).destroy(toRemove + .getExecutionStepHasIssuePK()); + update(); + } + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/FieldTypeServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/FieldTypeServer.java index 32b65c7a..1beb9600 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/FieldTypeServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/FieldTypeServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,61 +13,67 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.FieldType; -import com.validation.manager.core.db.controller.FieldTypeJpaController; -import java.util.List; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class FieldTypeServer extends FieldType - implements EntityServer { - - public static FieldType findType(String simpleName) { - PARAMETERS.clear(); - PARAMETERS.put("typeName", simpleName); - List r = DataBaseManager.namedQuery("FieldType.findByTypeName", PARAMETERS); - return r.isEmpty() ? null : (FieldType) r.get(0); - } - - @Override - public int write2DB() throws Exception { - FieldTypeJpaController c = new FieldTypeJpaController(DataBaseManager - .getEntityManagerFactory()); - if (getId() == null) { - FieldType ft = new FieldType(); - update(ft, this); - c.create(ft); - update(this, ft); - } else { - FieldType ft = getEntity(); - update(ft, this); - c.edit(ft); - update(this, ft); - } - return getId(); - } - - @Override - public FieldType getEntity() { - return new FieldTypeJpaController(DataBaseManager - .getEntityManagerFactory()).findFieldType(getId()); - } - - @Override - public void update(FieldType target, FieldType source) { - target.setHistoryFieldList(source.getHistoryFieldList()); - target.setId(source.getId()); - target.setTypeName(source.getTypeName()); - } - - @Override - public void update() { - update(this, getEntity()); - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.FieldType; +import com.validation.manager.core.db.controller.FieldTypeJpaController; +import java.util.List; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class FieldTypeServer extends FieldType + implements EntityServer { + + public static FieldType findType(String simpleName) { + PARAMETERS.clear(); + PARAMETERS.put("typeName", simpleName); + List r = DataBaseManager.namedQuery("FieldType.findByTypeName", PARAMETERS); + return r.isEmpty() ? null : (FieldType) r.get(0); + } + + @Override + public int write2DB() throws VMException { + try { + FieldTypeJpaController c = new FieldTypeJpaController(DataBaseManager + .getEntityManagerFactory()); + if (getId() == null) { + FieldType ft = new FieldType(); + update(ft, this); + c.create(ft); + update(this, ft); + } else { + FieldType ft = getEntity(); + update(ft, this); + c.edit(ft); + update(this, ft); + } + } + catch (Exception ex) { + throw new VMException(ex); + } + return getId(); + } + + @Override + public FieldType getEntity() { + return new FieldTypeJpaController(DataBaseManager + .getEntityManagerFactory()).findFieldType(getId()); + } + + @Override + public void update(FieldType target, FieldType source) { + target.setHistoryFieldList(source.getHistoryFieldList()); + target.setId(source.getId()); + target.setTypeName(source.getTypeName()); + } + + @Override + public void update() { + update(this, getEntity()); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/HistoryServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/HistoryServer.java index 96a12472..75924c1b 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/HistoryServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/HistoryServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,97 +13,104 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.controller.HistoryJpaController; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class HistoryServer extends History - implements EntityServer { - - public HistoryServer() { - super(); - } - - public HistoryServer(History history) { - super(history.getId()); - update(); - } - - @Override - public int write2DB() throws Exception { - HistoryJpaController c = new HistoryJpaController(DataBaseManager - .getEntityManagerFactory()); - if (getId() == null) { - History h = new History(); - update(h, this); - c.create(h); - update(this, h); - } else { - History h = getEntity(); - update(h, this); - c.edit(h); - update(this, h); - } - return getId(); - } - - @Override - public History getEntity() { - return new HistoryJpaController(DataBaseManager - .getEntityManagerFactory()).findHistory(getId()); - } - - @Override - public void update(History target, History source) { - target.setBaselineList(source.getBaselineList()); - target.setExecutionStepList(source.getExecutionStepList()); - target.setHistoryFieldList(source.getHistoryFieldList()); - target.setId(source.getId()); - target.setMajorVersion(source.getMajorVersion()); - target.setMidVersion(source.getMidVersion()); - target.setMinorVersion(source.getMinorVersion()); - target.setModificationTime(source.getModificationTime()); - target.setModifierId(source.getModifierId()); - target.setReason(source.getReason()); - target.setProjectId(source.getProjectId()); - target.setStep(source.getStep()); - target.setRequirementId(source.getRequirementId()); - target.setVmSettingId(source.getVmSettingId()); - } - - @Override - public void update() { - update(this, getEntity()); - } - - /** - * Do a major version of the item - */ - public void increaseMajor() { - setMajorVersion(getMajorVersion() + 1); - setMidVersion(0); - setMinorVersion(0); - } - - /** - * Do a medium version of the item - */ - public void increaseMid() { - setMidVersion(getMidVersion() + 1); - setMinorVersion(0); - } - - /** - * Do a minor version of the item - */ - public void increaseMinor() { - setMinorVersion(getMinorVersion() + 1); - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.controller.HistoryJpaController; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class HistoryServer extends History + implements EntityServer { + + public HistoryServer() { + super(); + } + + public HistoryServer(History history) { + super(history.getId()); + update(); + } + + @Override + public int write2DB() throws VMException { + try { + HistoryJpaController c = new HistoryJpaController(DataBaseManager + .getEntityManagerFactory()); + if (getId() == null) { + History h = new History(); + update(h, this); + c.create(h); + update(this, h); + } else { + History h = getEntity(); + update(h, this); + c.edit(h); + update(this, h); + } + } + catch (Exception ex) { + throw new VMException(ex); + } + return getId(); + } + + @Override + public History getEntity() { + return new HistoryJpaController(DataBaseManager + .getEntityManagerFactory()).findHistory(getId()); + } + + @Override + public void update(History target, History source) { + target.setBaselineList(source.getBaselineList()); + target.setExecutionStepList(source.getExecutionStepList()); + target.setHistoryFieldList(source.getHistoryFieldList()); + target.setId(source.getId()); + target.setMajorVersion(source.getMajorVersion()); + target.setMidVersion(source.getMidVersion()); + target.setMinorVersion(source.getMinorVersion()); + target.setModificationTime(source.getModificationTime()); + target.setModifierId(source.getModifierId()); + target.setReason(source.getReason()); + target.setProjectId(source.getProjectId()); + target.setStep(source.getStep()); + target.setRequirementId(source.getRequirementId()); + target.setVmSettingId(source.getVmSettingId()); + target.setVmUserId(source.getVmUserId()); + } + + @Override + public void update() { + update(this, getEntity()); + } + + /** + * Do a major version of the item + */ + public void increaseMajor() { + setMajorVersion(getMajorVersion() + 1); + setMidVersion(0); + setMinorVersion(0); + } + + /** + * Do a medium version of the item + */ + public void increaseMid() { + setMidVersion(getMidVersion() + 1); + setMinorVersion(0); + } + + /** + * Do a minor version of the item + */ + public void increaseMinor() { + setMinorVersion(getMinorVersion() + 1); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/IssueTypeServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/IssueTypeServer.java index 0fba4f70..e19a7a4d 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/IssueTypeServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/IssueTypeServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,71 +13,80 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.IssueType; -import com.validation.manager.core.db.controller.IssueTypeJpaController; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class IssueTypeServer extends IssueType - implements EntityServer { - - @Override - public int write2DB() throws Exception { - if (getId() == null) { - IssueType i = new IssueType(); - update(i, this); - new IssueTypeJpaController(DataBaseManager - .getEntityManagerFactory()).create(i); - update(this, i); - } else { - IssueType i = getEntity(); - update(i, this); - new IssueTypeJpaController(DataBaseManager - .getEntityManagerFactory()).edit(i); - update(this, i); - } - return getId(); - } - - @Override - public IssueType getEntity() { - return new IssueTypeJpaController(DataBaseManager - .getEntityManagerFactory()).findIssueType(getId()); - } - - @Override - public void update(IssueType target, IssueType source) { - target.setDescription(source.getDescription()); - target.setIssueList(source.getIssueList()); - target.setTypeName(source.getTypeName()); - } - - @Override - public void update() { - update(this, getEntity()); - } - - /** - * Get an Issue Type by name. - * - * @param typename name to search for - * @return Issue Type for the specified name or null if not found. - */ - public static IssueType getType(String typename) { - IssueType result = null; - for (IssueType type : new IssueTypeJpaController(DataBaseManager - .getEntityManagerFactory()).findIssueTypeEntities()) { - if (type.getTypeName().equals(typename)) { - result = type; - break; - } - } - return result; - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.db.IssueType; +import com.validation.manager.core.db.controller.IssueTypeJpaController; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class IssueTypeServer extends IssueType + implements EntityServer { + + public IssueTypeServer(int id) { + setId(id); + update(); + } + + public IssueTypeServer(String typeName) { + super(typeName); + } + + @Override + public int write2DB() throws Exception { + if (getId() == null) { + IssueType i = new IssueType(); + update(i, this); + new IssueTypeJpaController(DataBaseManager + .getEntityManagerFactory()).create(i); + update(this, i); + } else { + IssueType i = getEntity(); + update(i, this); + new IssueTypeJpaController(DataBaseManager + .getEntityManagerFactory()).edit(i); + update(this, i); + } + return getId(); + } + + @Override + public IssueType getEntity() { + return new IssueTypeJpaController(DataBaseManager + .getEntityManagerFactory()).findIssueType(getId()); + } + + @Override + public void update(IssueType target, IssueType source) { + target.setDescription(source.getDescription()); + target.setIssueList(source.getIssueList()); + target.setTypeName(source.getTypeName()); + } + + @Override + public void update() { + update(this, getEntity()); + } + + /** + * Get an Issue Type by name. + * + * @param typename name to search for + * @return Issue Type for the specified name or null if not found. + */ + public static IssueType getType(String typename) { + IssueType result = null; + for (IssueType type : new IssueTypeJpaController(DataBaseManager + .getEntityManagerFactory()).findIssueTypeEntities()) { + if (type.getTypeName().equals(typename)) { + result = type; + break; + } + } + return result; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/NotificationServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/NotificationServer.java index a05f1928..cd5a24a5 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/NotificationServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/NotificationServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,78 +13,84 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.Notification; -import com.validation.manager.core.db.NotificationPK; -import com.validation.manager.core.db.controller.NotificationJpaController; -import java.util.Date; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class NotificationServer extends Notification - implements EntityServer { - - public NotificationServer() { - super(); - } - - public NotificationServer(Notification n) { - setNotificationPK(n.getNotificationPK()); - update(); - } - - public NotificationServer(NotificationPK pk) { - setNotificationPK(pk); - update(); - } - - @Override - public int write2DB() throws Exception { - if (getNotificationPK() == null) { - Notification n = new Notification(); - if (getCreationDate() == null) { - setCreationDate(new Date()); - } - update(n, this); - new NotificationJpaController(DataBaseManager - .getEntityManagerFactory()).create(n); - setNotificationPK(n.getNotificationPK()); - } else { - Notification n = getEntity(); - update(n, this); - new NotificationJpaController(DataBaseManager - .getEntityManagerFactory()).edit(n); - } - update(); - return getNotificationPK().getId(); - } - - @Override - public Notification getEntity() { - return new NotificationJpaController(DataBaseManager - .getEntityManagerFactory()) - .findNotification(getNotificationPK()); - } - - @Override - public void update(Notification target, Notification source) { - target.setAcknowledgeDate(source.getAcknowledgeDate()); - target.setAuthor(source.getAuthor()); - target.setContent(source.getContent()); - target.setCreationDate(source.getCreationDate()); - target.setNotificationPK(source.getNotificationPK()); - target.setNotificationType(source.getNotificationType()); - target.setTargetUser(source.getTargetUser()); - target.setArchieved(source.getArchieved()); - } - - @Override - public void update() { - update(this, getEntity()); - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.Notification; +import com.validation.manager.core.db.NotificationPK; +import com.validation.manager.core.db.controller.NotificationJpaController; +import java.util.Date; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class NotificationServer extends Notification + implements EntityServer { + + public NotificationServer() { + super(); + } + + public NotificationServer(Notification n) { + setNotificationPK(n.getNotificationPK()); + update(); + } + + public NotificationServer(NotificationPK pk) { + setNotificationPK(pk); + update(); + } + + @Override + public int write2DB() throws VMException { + try { + if (getNotificationPK() == null) { + Notification n = new Notification(); + if (getCreationDate() == null) { + setCreationDate(new Date()); + } + update(n, this); + new NotificationJpaController(DataBaseManager + .getEntityManagerFactory()).create(n); + setNotificationPK(n.getNotificationPK()); + } else { + Notification n = getEntity(); + update(n, this); + new NotificationJpaController(DataBaseManager + .getEntityManagerFactory()).edit(n); + } + update(); + } + catch (Exception ex) { + throw new VMException(ex); + } + return getNotificationPK().getId(); + } + + @Override + public Notification getEntity() { + return new NotificationJpaController(DataBaseManager + .getEntityManagerFactory()) + .findNotification(getNotificationPK()); + } + + @Override + public void update(Notification target, Notification source) { + target.setAcknowledgeDate(source.getAcknowledgeDate()); + target.setAuthor(source.getAuthor()); + target.setContent(source.getContent()); + target.setCreationDate(source.getCreationDate()); + target.setNotificationPK(source.getNotificationPK()); + target.setNotificationType(source.getNotificationType()); + target.setTargetUser(source.getTargetUser()); + target.setArchieved(source.getArchieved()); + } + + @Override + public void update() { + update(this, getEntity()); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/ProjectServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/ProjectServer.java index 963b9765..520d2d4e 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/ProjectServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/ProjectServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,153 +13,135 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.VMException; -import com.validation.manager.core.db.Project; -import com.validation.manager.core.db.TestProject; -import com.validation.manager.core.db.controller.ProjectJpaController; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import java.util.logging.Level; -import static java.util.logging.Logger.getLogger; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class ProjectServer extends Project - implements EntityServer, VersionableServer { - - private static final long serialVersionUID = 3434510483033583117L; - - public ProjectServer(String name, String notes) { - super(name); - setNotes(notes); - setProjectList(new ArrayList<>()); - setRequirementSpecList(new ArrayList<>()); - setTestProjectList(new ArrayList<>()); - } - - public ProjectServer(int id) { - Project product = new ProjectJpaController( - getEntityManagerFactory()).findProject(id); - update((ProjectServer) this, product); - } - - public ProjectServer(Project p) { - Project product = new ProjectJpaController( - getEntityManagerFactory()).findProject(p.getId()); - update((ProjectServer) this, product); - } - - @Override - public int write2DB() throws IllegalOrphanException, - NonexistentEntityException, Exception { - Project p; - if (getId() == null) { - p = new Project(getName()); - update(p, this); - new ProjectJpaController(getEntityManagerFactory()).create(p); - setId(p.getId()); - } else { - p = getEntity(); - update(p, this); - new ProjectJpaController(getEntityManagerFactory()).edit(p); - } - return getId(); - } - - public static void deleteProject(Project p) throws VMException { - if (p.getProjectList().isEmpty()) { - try { - if (p.getRequirementSpecList().isEmpty()) { - new ProjectJpaController(getEntityManagerFactory()) - .destroy(p.getId()); - } else { - throw new VMException("Unable to delete project with Requirement Specifications!"); - } - } - catch (IllegalOrphanException | NonexistentEntityException ex) { - getLogger(ProjectServer.class.getName()).log(Level.SEVERE, null, ex); - } - } else { - throw new VMException("Unable to delete project with children!"); - } - } - - @Override - public Project getEntity() { - return new ProjectJpaController(getEntityManagerFactory()) - .findProject(getId()); - } - - @Override - public void update(Project target, Project source) { - target.setNotes(source.getNotes()); - target.setName(source.getName()); - target.setParentProjectId(source.getParentProjectId()); - target.setProjectList(source.getProjectList()); - target.setRequirementSpecList(source.getRequirementSpecList()); - target.setTestProjectList(source.getTestProjectList()); - target.setId(source.getId()); - super.update(target, source); - } - - public static List getProjects() { - return new ProjectJpaController(getEntityManagerFactory()) - .findProjectEntities(); - } - - public List getChildren() { - ArrayList children = new ArrayList<>(); - getProjects().stream().filter((p) - -> (p.getParentProjectId() != null)).filter((p) - -> (p.getParentProjectId().getId().equals(getId()))) - .forEachOrdered((p) -> { - children.add(p); - }); - return children; - } - - @Override - public void update() { - update(this, getEntity()); - } - - public void copy(Project newProject) { - update(this, newProject); - } - - /** - * Get the Test Projects for this project. - * - * @return Test projects for this project. - */ - public List getTestProjects() { - return getTestProjects(false); - } - - /** - * Get the Test Projects for this project. - * - * @param includeSubProjects true to include the sub projects as well. - * - * @return Test projects for this project. - */ - public List getTestProjects(boolean includeSubProjects) { - List tps = new ArrayList<>(); - tps.addAll(getTestProjectList()); - if (includeSubProjects) { - for (Project p : getProjectList()) { - tps.addAll(new ProjectServer(p) - .getTestProjects(includeSubProjects)); - } - } - return tps; - } -} +package com.validation.manager.core.server.core; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.Project; +import com.validation.manager.core.db.TestProject; +import com.validation.manager.core.db.controller.ProjectJpaController; +import java.util.ArrayList; +import java.util.List; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class ProjectServer extends Project + implements EntityServer, VersionableServer { + + private static final long serialVersionUID = 3_434_510_483_033_583_117L; + + public ProjectServer(String name, String notes) { + super(name); + setNotes(notes); + setProjectList(new ArrayList<>()); + setRequirementSpecList(new ArrayList<>()); + setTestProjectList(new ArrayList<>()); + } + + public ProjectServer(int id) { + Project product = new ProjectJpaController( + getEntityManagerFactory()).findProject(id); + update((ProjectServer) this, product); + } + + public ProjectServer(Project p) { + Project product = new ProjectJpaController( + getEntityManagerFactory()).findProject(p.getId()); + update((ProjectServer) this, product); + } + + @Override + public int write2DB() throws VMException { + try { + Project p; + if (getId() == null) { + p = new Project(getName()); + update(p, this); + new ProjectJpaController(getEntityManagerFactory()).create(p); + setId(p.getId()); + } else { + p = getEntity(); + update(p, this); + new ProjectJpaController(getEntityManagerFactory()).edit(p); + } + } + catch (Exception ex) { + throw new VMException(ex); + } + return getId(); + } + + @Override + public Project getEntity() { + return new ProjectJpaController(getEntityManagerFactory()) + .findProject(getId()); + } + + @Override + public void update(Project target, Project source) { + target.setNotes(source.getNotes()); + target.setName(source.getName()); + target.setParentProjectId(source.getParentProjectId()); + target.setProjectList(source.getProjectList()); + target.setRequirementSpecList(source.getRequirementSpecList()); + target.setTestProjectList(source.getTestProjectList()); + target.setId(source.getId()); + super.update(target, source); + } + + public static List getProjects() { + return new ProjectJpaController(getEntityManagerFactory()) + .findProjectEntities(); + } + + public List getChildren() { + ArrayList children = new ArrayList<>(); + getProjects().stream().filter((p) + -> (p.getParentProjectId() != null)).filter((p) + -> (p.getParentProjectId().getId().equals(getId()))) + .forEachOrdered((p) -> { + children.add(p); + }); + return children; + } + + @Override + public void update() { + update(this, getEntity()); + } + + public void copy(Project newProject) { + update(this, newProject); + } + + /** + * Get the Test Projects for this project. + * + * @return Test projects for this project. + */ + public List getTestProjects() { + return getTestProjects(false); + } + + /** + * Get the Test Projects for this project. + * + * @param includeSubProjects true to include the sub projects as well. + * + * @return Test projects for this project. + */ + public List getTestProjects(boolean includeSubProjects) { + List tps = new ArrayList<>(); + tps.addAll(getTestProjectList()); + if (includeSubProjects) { + for (Project p : getProjectList()) { + tps.addAll(new ProjectServer(p) + .getTestProjects(includeSubProjects)); + } + } + return tps; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/RequirementStatusServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/RequirementStatusServer.java index 81313879..963bc3fd 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/RequirementStatusServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/RequirementStatusServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,65 +13,69 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.RequirementStatus; -import com.validation.manager.core.db.controller.RequirementStatusJpaController; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class RequirementStatusServer extends RequirementStatus - implements EntityServer { - - public RequirementStatusServer(Integer id) { - RequirementStatusJpaController controller - = new RequirementStatusJpaController( - getEntityManagerFactory()); - RequirementStatus rs = controller.findRequirementStatus(id); - if (rs != null) { - update(RequirementStatusServer.this, rs); - } - } - - @Override - public int write2DB() throws Exception { - RequirementStatus p; - RequirementStatusJpaController controller - = new RequirementStatusJpaController( - getEntityManagerFactory()); - if (getId() > 0) { - p = controller.findRequirementStatus(getId()); - update(p, this); - controller.edit(p); - } else { - p = new RequirementStatus(getStatus()); - update(p, this); - controller.create(p); - setId(p.getId()); - } - return getId(); - } - - @Override - public RequirementStatus getEntity() { - return new RequirementStatusJpaController( - getEntityManagerFactory()) - .findRequirementStatus(getId()); - } - - @Override - public void update(RequirementStatus target, RequirementStatus source) { - target.setId(source.getId()); - target.setStatus(source.getStatus()); - target.setRequirementList(source.getRequirementList()); - } - - @Override - public void update() { - update(this, getEntity()); - } -} +package com.validation.manager.core.server.core; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.db.RequirementStatus; +import com.validation.manager.core.db.controller.RequirementStatusJpaController; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class RequirementStatusServer extends RequirementStatus + implements EntityServer { + + public RequirementStatusServer(Integer id) { + RequirementStatusJpaController controller + = new RequirementStatusJpaController( + getEntityManagerFactory()); + RequirementStatus rs = controller.findRequirementStatus(id); + if (rs != null) { + update(RequirementStatusServer.this, rs); + } + } + + public RequirementStatusServer(String status) { + super(status); + } + + @Override + public int write2DB() throws Exception { + RequirementStatus p; + RequirementStatusJpaController controller + = new RequirementStatusJpaController( + getEntityManagerFactory()); + if (getId() == null) { + p = new RequirementStatus(getStatus()); + update(p, this); + controller.create(p); + setId(p.getId()); + } else { + p = controller.findRequirementStatus(getId()); + update(p, this); + controller.edit(p); + } + return getId(); + } + + @Override + public RequirementStatus getEntity() { + return new RequirementStatusJpaController( + getEntityManagerFactory()) + .findRequirementStatus(getId()); + } + + @Override + public void update(RequirementStatus target, RequirementStatus source) { + target.setId(source.getId()); + target.setStatus(source.getStatus()); + target.setRequirementList(source.getRequirementList()); + } + + @Override + public void update() { + update(this, getEntity()); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/RequirementTypeServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/RequirementTypeServer.java index 24f80b0c..2cce6640 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/RequirementTypeServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/RequirementTypeServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,75 +13,77 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.RequirementType; -import com.validation.manager.core.db.controller.RequirementTypeJpaController; -import java.util.ArrayList; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class RequirementTypeServer extends RequirementType - implements EntityServer { - - public RequirementTypeServer(RequirementType rt) { - RequirementType temp - = new RequirementTypeJpaController( - getEntityManagerFactory()) - .findRequirementType(rt.getId()); - update((RequirementType) this, temp); - } - - public RequirementTypeServer(String name) { - super(name); - setId(0); - setRequirementList(new ArrayList<>()); - } - - @Override - public int write2DB() throws Exception { - RequirementType rt; - if (getId() > 0) { - rt = new RequirementTypeJpaController(getEntityManagerFactory()).findRequirementType(getId()); - update(rt, this); - new RequirementTypeJpaController(getEntityManagerFactory()).edit(rt); - } else { - rt = new RequirementType(getName()); - update(rt, this); - new RequirementTypeJpaController(getEntityManagerFactory()).create(rt); - setId(rt.getId()); - } - return getId(); - } - - @Override - public RequirementType getEntity() { - return new RequirementTypeJpaController( - getEntityManagerFactory()) - .findRequirementType(getId()); - } - - @Override - public void update(RequirementType target, RequirementType source) { - target.setDescription(source.getDescription()); - target.setName(source.getName()); - target.setId(source.getId()); - target.setRequirementList(source.getRequirementList()); - target.setLevel(source.getLevel()); - } - - @Override - public void update() { - update(this, getEntity()); - } - - public static Iterable getRequirementTypes() { - return new RequirementTypeJpaController( - getEntityManagerFactory()) - .findRequirementTypeEntities(); - } -} +package com.validation.manager.core.server.core; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.db.RequirementType; +import com.validation.manager.core.db.controller.RequirementTypeJpaController; +import java.util.ArrayList; +import java.util.List; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class RequirementTypeServer extends RequirementType + implements EntityServer { + + public RequirementTypeServer(RequirementType rt) { + RequirementType temp + = new RequirementTypeJpaController( + getEntityManagerFactory()) + .findRequirementType(rt.getId()); + update((RequirementType) this, temp); + } + + public RequirementTypeServer(String name) { + super(name); + setId(0); + setRequirementList(new ArrayList<>()); + } + + @Override + public int write2DB() throws Exception { + RequirementType rt; + if (getId() > 0) { + rt = new RequirementTypeJpaController(getEntityManagerFactory()).findRequirementType(getId()); + update(rt, this); + new RequirementTypeJpaController(getEntityManagerFactory()).edit(rt); + } else { + rt = new RequirementType(getName()); + update(rt, this); + new RequirementTypeJpaController(getEntityManagerFactory()).create(rt); + setId(rt.getId()); + } + update(); + return getId(); + } + + @Override + public RequirementType getEntity() { + return new RequirementTypeJpaController( + getEntityManagerFactory()) + .findRequirementType(getId()); + } + + @Override + public void update(RequirementType target, RequirementType source) { + target.setDescription(source.getDescription()); + target.setName(source.getName()); + target.setId(source.getId()); + target.setRequirementList(source.getRequirementList()); + target.setLevel(source.getLevel()); + } + + @Override + public void update() { + update(this, getEntity()); + } + + public static List getRequirementTypes() { + return new RequirementTypeJpaController( + getEntityManagerFactory()) + .findRequirementTypeEntities(); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/ReviewResultServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/ReviewResultServer.java index e7ad759e..e391f98c 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/ReviewResultServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/ReviewResultServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,69 +13,78 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.ReviewResult; -import com.validation.manager.core.db.controller.ReviewResultJpaController; -import java.util.List; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class ReviewResultServer extends ReviewResult - implements EntityServer { - - public static ReviewResult getReview(String review) { - PARAMETERS.clear(); - PARAMETERS.put("reviewName", review); - List r = DataBaseManager.namedQuery("ReviewResult.findByReviewName", - PARAMETERS); - if (r.isEmpty()) { - return null; - } else { - return (ReviewResult) r.get(0); - } - } - - @Override - public int write2DB() throws Exception { - ReviewResultJpaController c - = new ReviewResultJpaController(DataBaseManager - .getEntityManagerFactory()); - if (getId() == null) { - ReviewResult rr = new ReviewResult(); - update(rr, this); - c.create(rr); - update(this, rr); - } else { - ReviewResult rr = getEntity(); - update(rr, this); - c.edit(rr); - update(this, rr); - } - return getId(); - } - - @Override - public ReviewResult getEntity() { - ReviewResultJpaController c - = new ReviewResultJpaController(DataBaseManager - .getEntityManagerFactory()); - return c.findReviewResult(getId()); - } - - @Override - public void update(ReviewResult target, ReviewResult source) { - target.setExecutionStepList(source.getExecutionStepList()); - target.setId(source.getId()); - target.setReviewName(source.getReviewName()); - } - - @Override - public void update() { - update(this, getEntity()); - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.db.ReviewResult; +import com.validation.manager.core.db.controller.ReviewResultJpaController; +import java.util.List; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ReviewResultServer extends ReviewResult + implements EntityServer { + + public ReviewResultServer(int id) { + setId(id); + update(); + } + + public ReviewResultServer(String reviewName) { + super(reviewName); + } + + public static ReviewResult getReview(String review) { + PARAMETERS.clear(); + PARAMETERS.put("reviewName", review); + List r = DataBaseManager.namedQuery("ReviewResult.findByReviewName", + PARAMETERS); + if (r.isEmpty()) { + return null; + } else { + return (ReviewResult) r.get(0); + } + } + + @Override + public int write2DB() throws Exception { + ReviewResultJpaController c + = new ReviewResultJpaController(DataBaseManager + .getEntityManagerFactory()); + if (getId() == null) { + ReviewResult rr = new ReviewResult(); + update(rr, this); + c.create(rr); + update(this, rr); + } else { + ReviewResult rr = getEntity(); + update(rr, this); + c.edit(rr); + update(this, rr); + } + return getId(); + } + + @Override + public ReviewResult getEntity() { + ReviewResultJpaController c + = new ReviewResultJpaController(DataBaseManager + .getEntityManagerFactory()); + return c.findReviewResult(getId()); + } + + @Override + public void update(ReviewResult target, ReviewResult source) { + target.setExecutionStepList(source.getExecutionStepList()); + target.setId(source.getId()); + target.setReviewName(source.getReviewName()); + } + + @Override + public void update() { + update(this, getEntity()); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/RiskControlServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/RiskControlServer.java index 70a4e191..8d4d8a3a 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/RiskControlServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/RiskControlServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,97 +13,98 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.RiskControl; -import com.validation.manager.core.db.RiskControlPK; -import com.validation.manager.core.db.controller.RiskControlJpaController; -import com.validation.manager.core.db.controller.RiskControlTypeJpaController; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.logging.Level; -import static java.util.logging.Logger.getLogger; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class RiskControlServer extends RiskControl - implements EntityServer { - - public RiskControlServer(RiskControlPK riskControlPK) { - super(riskControlPK); - setRiskControlType(new RiskControlTypeJpaController( - getEntityManagerFactory()).findRiskControlType( - riskControlPK.getRiskControlTypeId())); - } - - public RiskControlServer(RiskControl riskControl) { - super(riskControl.getRiskControlPK()); - setRiskControlType(new RiskControlTypeJpaController( - getEntityManagerFactory()).findRiskControlType( - riskControlPK.getRiskControlTypeId())); - } - - public RiskControlServer(int riskControlTypeId) { - super(new RiskControlPK(riskControlTypeId)); - setRiskControlType(new RiskControlTypeJpaController( - getEntityManagerFactory()).findRiskControlType(riskControlTypeId)); - } - - @Override - public int write2DB() throws NonexistentEntityException, Exception { - RiskControlJpaController controller - = new RiskControlJpaController(getEntityManagerFactory()); - if (getRiskControlPK().getId() > 0) { - RiskControl target = controller.findRiskControl(getRiskControlPK()); - update(target, this); - controller.edit(target); - } else { - RiskControl target = new RiskControl(getRiskControlPK()); - update(target, this); - controller.create(target); - setRiskControlPK(target.getRiskControlPK()); - } - return getRiskControlPK().getId(); - } - - public static boolean deleteRiskControl(RiskControl rc) { - try { - new RiskControlJpaController( - getEntityManagerFactory()) - .destroy(rc.getRiskControlPK()); - return true; - } - catch (NonexistentEntityException | IllegalOrphanException ex) { - getLogger(RiskControlServer.class.getName()).log( - Level.SEVERE, null, ex); - } - return false; - } - - @Override - public RiskControl getEntity() { - return new RiskControlJpaController( - getEntityManagerFactory()) - .findRiskControl(getRiskControlPK()); - } - - @Override - public void update(RiskControl target, RiskControl source) { - target.setRiskControlHasRequirementList(source - .getRiskControlHasRequirementList()); - target.setRiskControlHasTestCaseList(source - .getRiskControlHasTestCaseList()); - target.setRiskItemList(source.getRiskItemList()); - target.setRiskItemList1(source.getRiskItemList1()); - target.setRiskControlType(source.getRiskControlType()); - } - - @Override - public void update() { - update(this, getEntity()); - } -} +package com.validation.manager.core.server.core; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.db.RiskControl; +import com.validation.manager.core.db.RiskControlPK; +import com.validation.manager.core.db.controller.RiskControlJpaController; +import com.validation.manager.core.db.controller.RiskControlTypeJpaController; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.logging.Level; +import static java.util.logging.Logger.getLogger; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class RiskControlServer extends RiskControl + implements EntityServer { + + public RiskControlServer(RiskControlPK riskControlPK) { + super(riskControlPK); + setRiskControlType(new RiskControlTypeJpaController( + getEntityManagerFactory()).findRiskControlType( + riskControlPK.getRiskControlTypeId())); + update(); + } + + public RiskControlServer(RiskControl riskControl) { + super(riskControl.getRiskControlPK()); + setRiskControlType(new RiskControlTypeJpaController( + getEntityManagerFactory()).findRiskControlType( + riskControlPK.getRiskControlTypeId())); + } + + public RiskControlServer(int riskControlTypeId) { + super(new RiskControlPK(riskControlTypeId)); + setRiskControlType(new RiskControlTypeJpaController( + getEntityManagerFactory()).findRiskControlType(riskControlTypeId)); + } + + @Override + public int write2DB() throws NonexistentEntityException, Exception { + RiskControlJpaController controller + = new RiskControlJpaController(getEntityManagerFactory()); + if (getRiskControlPK().getId() > 0) { + RiskControl target = controller.findRiskControl(getRiskControlPK()); + update(target, this); + controller.edit(target); + } else { + RiskControl target = new RiskControl(getRiskControlPK()); + update(target, this); + controller.create(target); + setRiskControlPK(target.getRiskControlPK()); + } + return getRiskControlPK().getId(); + } + + public static boolean deleteRiskControl(RiskControl rc) { + try { + new RiskControlJpaController( + getEntityManagerFactory()) + .destroy(rc.getRiskControlPK()); + return true; + } + catch (NonexistentEntityException | IllegalOrphanException ex) { + getLogger(RiskControlServer.class.getName()).log( + Level.SEVERE, null, ex); + } + return false; + } + + @Override + public RiskControl getEntity() { + return new RiskControlJpaController( + getEntityManagerFactory()) + .findRiskControl(getRiskControlPK()); + } + + @Override + public void update(RiskControl target, RiskControl source) { + target.setRiskControlHasRequirementList(source + .getRiskControlHasRequirementList()); + target.setRiskControlHasTestCaseList(source + .getRiskControlHasTestCaseList()); + target.setRiskItemList(source.getRiskItemList()); + target.setRiskItemList1(source.getRiskItemList1()); + target.setRiskControlType(source.getRiskControlType()); + } + + @Override + public void update() { + update(this, getEntity()); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/RoleServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/RoleServer.java index 1d55e1e2..c3609ea5 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/RoleServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/RoleServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,76 +13,84 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.Role; -import com.validation.manager.core.db.controller.RoleJpaController; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class RoleServer extends Role implements EntityServer { - - private static final Map PARAMETERS = new HashMap<>(); - private final RoleJpaController c - = new RoleJpaController(DataBaseManager.getEntityManagerFactory()); - - public RoleServer(String description) { - super(description); - update(RoleServer.this, getRole(description)); - } - - public static Role getRole(String role) { - Role r = null; - PARAMETERS.clear(); - PARAMETERS.put("name", role); - List result = DataBaseManager.namedQuery("Role.findByName", - PARAMETERS); - if (!result.isEmpty()) { - r = (Role) result.get(0); - } - return r; - } - - @Override - public int write2DB() throws Exception { - if (getId() == null) { - Role r = new Role(); - update(r, this); - c.create(r); - update(this, r); - } else { - Role r = getEntity(); - update(r, this); - c.edit(r); - update(this, r); - } - return getId(); - } - - @Override - public void update() { - update(RoleServer.this, getEntity()); - } - - @Override - public Role getEntity() { - return getId() == null ? null : c.findRole(getId()); - } - - @Override - public void update(Role target, Role source) { - target.setDescription(source.getDescription()); - target.setId(source.getId()); - target.setRoleName(source.getRoleName()); - target.setUserRightList(source.getUserRightList()); - target.setUserTestPlanRoleList(source.getUserTestPlanRoleList()); - target.setVmUserList(source.getVmUserList()); - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.Role; +import com.validation.manager.core.db.controller.RoleJpaController; +import java.util.List; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class RoleServer extends Role implements EntityServer { + + private final RoleJpaController c + = new RoleJpaController(DataBaseManager.getEntityManagerFactory()); + + public RoleServer(int id) { + setId(id); + update(); + } + + public RoleServer(String description) { + super(description); + update(RoleServer.this, getRole(description)); + } + + public static Role getRole(String role) { + Role r = null; + PARAMETERS.clear(); + PARAMETERS.put("name", role); + List result = DataBaseManager.namedQuery("Role.findByName", + PARAMETERS); + if (!result.isEmpty()) { + r = (Role) result.get(0); + } + return r; + } + + @Override + public int write2DB() throws VMException { + try { + if (getId() == null) { + Role r = new Role(); + update(r, this); + c.create(r); + update(this, r); + } else { + Role r = getEntity(); + update(r, this); + c.edit(r); + update(this, r); + } + } + catch (Exception ex) { + throw new VMException(ex); + } + return getId(); + } + + @Override + public void update() { + update(RoleServer.this, getEntity()); + } + + @Override + public Role getEntity() { + return getId() == null ? null : c.findRole(getId()); + } + + @Override + public void update(Role target, Role source) { + target.setDescription(source.getDescription()); + target.setId(source.getId()); + target.setRoleName(source.getRoleName()); + target.setUserRightList(source.getUserRightList()); + target.setUserTestPlanRoleList(source.getUserTestPlanRoleList()); + target.setVmUserList(source.getVmUserList()); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/TestCaseExecutionServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/TestCaseExecutionServer.java index 504832a6..ce704eab 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/TestCaseExecutionServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/TestCaseExecutionServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,214 +13,214 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.Project; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.TestCaseExecution; -import com.validation.manager.core.db.TestPlan; -import com.validation.manager.core.db.TestProject; -import com.validation.manager.core.db.controller.ExecutionStepJpaController; -import com.validation.manager.core.db.controller.TestCaseExecutionJpaController; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.ArrayList; -import java.util.List; -import java.util.Objects; -import org.openide.util.Exceptions; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class TestCaseExecutionServer extends TestCaseExecution - implements EntityServer { - - public TestCaseExecutionServer(String name, String scope) { - super(name, scope); - } - - public TestCaseExecutionServer(int id) { - super.setId(id); - update(); - } - - public TestCaseExecutionServer(TestCaseExecution tce) { - super.setId(tce.getId()); - update(); - } - - public TestCaseExecutionServer() { - } - - /** - * Add a Test Case to this execution. - * - * @param tc Test Case to add - */ - public void addTestCase(TestCase tc) { - try { - ExecutionStepJpaController econtroller - = new ExecutionStepJpaController(DataBaseManager - .getEntityManagerFactory()); - tc.getStepList().forEach((s) -> { - ExecutionStep es = new ExecutionStep(getId(), - s.getStepPK().getId(), s.getStepPK().getTestCaseId()); - es.setStep(s); - es.setStepHistory(s.getHistoryList() - .get(s.getHistoryList().size() - 1)); - es.setTestCaseExecution(getEntity()); - try { - econtroller.create(es); - getExecutionStepList().add(es); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - }); - write2DB(); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - } - - @Override - public int write2DB() throws Exception { - TestCaseExecutionJpaController controller - = new TestCaseExecutionJpaController(DataBaseManager - .getEntityManagerFactory()); - TestCaseExecution tce; - if (getId() == null) { - //New one - tce = new TestCaseExecution(); - update(tce, this); - controller.create(tce); - setId(tce.getId()); - } else { - tce = controller.findTestCaseExecution(getId()); - update(tce, this); - controller.edit(tce); - } - update(); - return getId(); - } - - @Override - public TestCaseExecution getEntity() { - return new TestCaseExecutionJpaController(DataBaseManager - .getEntityManagerFactory()).findTestCaseExecution(getId()); - } - - @Override - public void update(TestCaseExecution target, TestCaseExecution source) { - target.setConclusion(source.getConclusion()); - target.setId(source.getId()); - target.setScope(source.getScope()); - target.setName(source.getName()); - if (target.getExecutionStepList() == null) { - target.setExecutionStepList(new ArrayList<>()); - } else { - target.getExecutionStepList().clear(); - } - if (source.getExecutionStepList() != null) { - source.getExecutionStepList().forEach((es) -> { - target.getExecutionStepList().add(es); - }); - } - } - - @Override - public void update() { - update(this, getEntity()); - } - - /** - * Add a complete Test Project to the execution. - * - * @param tp Test Project to add - */ - public void addTestProject(TestProject tp) { - tp.getTestPlanList().forEach((plan) -> { - addTestPlan(plan); - }); - } - - /** - * Add a complete Test Plan to the execution. - * - * @param plan Test Plan to add - */ - private void addTestPlan(TestPlan plan) { - plan.getTestCaseList().forEach((tc) -> { - addTestCase(tc); - }); - } - - /** - * List of Executions for the provided project. - * - * @param p project to look into. - * @return List of Executions for the provided project. - */ - public static List getExecutions(Project p) { - List results = new ArrayList<>(); - p.getTestProjectList().forEach(tp -> { - tp.getTestPlanList().forEach(plan -> { - plan.getTestCaseList().forEach(tc -> { - tc.getStepList().forEach(s -> { - s.getExecutionStepList().forEach(es -> { - results.add(es.getTestCaseExecution()); - }); - }); - }); - }); - }); - return results; - } - - public void removeTestCase(TestCase tc) throws Exception { - List toDelete = new ArrayList<>(); - getExecutionStepList().forEach(es -> { - if (Objects.equals(es.getStep().getTestCase() - .getId(), tc.getId())) { - //Same test case - toDelete.add(es); - } - }); - getExecutionStepList().removeAll(toDelete); - ExecutionStepJpaController c - = new ExecutionStepJpaController(DataBaseManager - .getEntityManagerFactory()); - toDelete.forEach(es -> { - try { - ExecutionStepServer ess = new ExecutionStepServer(es); - ess.getExecutionStepHasAttachmentList().forEach(att -> { - try { - ess.removeAttachment(att.getAttachment()); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - }); - ess.getExecutionStepHasIssueList().forEach(issue -> { - try { - ess.removeIssue(issue.getIssue()); - } - catch (NonexistentEntityException ex) { - Exceptions.printStackTrace(ex); - } - }); - ess.getEntity(); - c.destroy(ess.getExecutionStepPK()); - } - catch (IllegalOrphanException | NonexistentEntityException ex) { - Exceptions.printStackTrace(ex); - } - }); - write2DB(); - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.Project; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.TestCaseExecution; +import com.validation.manager.core.db.TestPlan; +import com.validation.manager.core.db.TestProject; +import com.validation.manager.core.db.controller.ExecutionStepJpaController; +import com.validation.manager.core.db.controller.TestCaseExecutionJpaController; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import org.openide.util.Exceptions; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class TestCaseExecutionServer extends TestCaseExecution + implements EntityServer { + + public TestCaseExecutionServer(String name, String scope) { + super(name, scope); + } + + public TestCaseExecutionServer(int id) { + super.setId(id); + update(); + } + + public TestCaseExecutionServer(TestCaseExecution tce) { + super.setId(tce.getId()); + update(); + } + + public TestCaseExecutionServer() { + } + + /** + * Add a Test Case to this execution. + * + * @param tc Test Case to add + */ + public void addTestCase(TestCase tc) { + try { + ExecutionStepJpaController econtroller + = new ExecutionStepJpaController(DataBaseManager + .getEntityManagerFactory()); + tc.getStepList().forEach((s) -> { + ExecutionStep es = new ExecutionStep(getId(), + s.getStepPK().getId(), s.getStepPK().getTestCaseId()); + es.setStep(s); + es.setStepHistory(s.getHistoryList() + .get(s.getHistoryList().size() - 1)); + es.setTestCaseExecution(getEntity()); + try { + econtroller.create(es); + getExecutionStepList().add(es); + } + catch (Exception ex) { + Exceptions.printStackTrace(ex); + } + }); + write2DB(); + } + catch (Exception ex) { + Exceptions.printStackTrace(ex); + } + } + + @Override + public int write2DB() throws Exception { + TestCaseExecutionJpaController controller + = new TestCaseExecutionJpaController(DataBaseManager + .getEntityManagerFactory()); + TestCaseExecution tce; + if (getId() == null) { + //New one + tce = new TestCaseExecution(); + update(tce, this); + controller.create(tce); + setId(tce.getId()); + } else { + tce = controller.findTestCaseExecution(getId()); + update(tce, this); + controller.edit(tce); + } + update(); + return getId(); + } + + @Override + public TestCaseExecution getEntity() { + return new TestCaseExecutionJpaController(DataBaseManager + .getEntityManagerFactory()).findTestCaseExecution(getId()); + } + + @Override + public void update(TestCaseExecution target, TestCaseExecution source) { + target.setConclusion(source.getConclusion()); + target.setId(source.getId()); + target.setScope(source.getScope()); + target.setName(source.getName()); + if (target.getExecutionStepList() == null) { + target.setExecutionStepList(new ArrayList<>()); + } else { + target.getExecutionStepList().clear(); + } + if (source.getExecutionStepList() != null) { + source.getExecutionStepList().forEach((es) -> { + target.getExecutionStepList().add(es); + }); + } + } + + @Override + public void update() { + update(this, getEntity()); + } + + /** + * Add a complete Test Project to the execution. + * + * @param tp Test Project to add + */ + public void addTestProject(TestProject tp) { + tp.getTestPlanList().forEach((plan) -> { + addTestPlan(plan); + }); + } + + /** + * Add a complete Test Plan to the execution. + * + * @param plan Test Plan to add + */ + private void addTestPlan(TestPlan plan) { + plan.getTestCaseList().forEach((tc) -> { + addTestCase(tc); + }); + } + + /** + * List of Executions for the provided project. + * + * @param p project to look into. + * @return List of Executions for the provided project. + */ + public static List getExecutions(Project p) { + List results = new ArrayList<>(); + p.getTestProjectList().forEach(tp -> { + tp.getTestPlanList().forEach(plan -> { + plan.getTestCaseList().forEach(tc -> { + tc.getStepList().forEach(s -> { + s.getExecutionStepList().forEach(es -> { + results.add(es.getTestCaseExecution()); + }); + }); + }); + }); + }); + return results; + } + + public void removeTestCase(TestCase tc) throws Exception { + List toDelete = new ArrayList<>(); + getExecutionStepList().forEach(es -> { + if (Objects.equals(es.getStep().getTestCase() + .getId(), tc.getId())) { + //Same test case + toDelete.add(es); + } + }); + getExecutionStepList().removeAll(toDelete); + ExecutionStepJpaController c + = new ExecutionStepJpaController(DataBaseManager + .getEntityManagerFactory()); + toDelete.forEach(es -> { + try { + ExecutionStepServer ess = new ExecutionStepServer(es); + ess.getExecutionStepHasAttachmentList().forEach(att -> { + try { + ess.removeAttachment(att.getAttachment()); + } + catch (Exception ex) { + Exceptions.printStackTrace(ex); + } + }); + ess.getExecutionStepHasIssueList().forEach(issue -> { + try { + ess.removeIssue(issue.getIssue()); + } + catch (NonexistentEntityException ex) { + Exceptions.printStackTrace(ex); + } + }); + ess.getEntity(); + c.destroy(ess.getExecutionStepPK()); + } + catch (IllegalOrphanException | NonexistentEntityException ex) { + Exceptions.printStackTrace(ex); + } + }); + write2DB(); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/TestCaseServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/TestCaseServer.java index ca1b5a1f..4f034766 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/TestCaseServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/TestCaseServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,107 +13,107 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.Requirement; -import com.validation.manager.core.db.Step; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.controller.TestCaseJpaController; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import java.util.ArrayList; -import java.util.Date; -import java.util.List; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class TestCaseServer extends TestCase - implements EntityServer { - - public TestCaseServer(int id) { - super(id); - update(); - } - - public TestCaseServer(TestCase tc) { - super.setId(tc.getId()); - update(); - } - - public TestCaseServer(String name, Date creationDate) { - super(name, creationDate); - } - - @Override - public int write2DB() throws IllegalOrphanException, - NonexistentEntityException, Exception { - TestCaseJpaController controller - = new TestCaseJpaController(getEntityManagerFactory()); - if (getId() != null && getId() > 0) { - TestCase temp = controller.findTestCase(getId()); - update(temp, this); - controller.edit(temp); - } else { - TestCase temp = new TestCase(getName(), getCreationDate()); - temp.setCreationDate(new Date()); - controller.create(temp); - setId(temp.getId()); - } - update(); - return getId(); - } - - @Override - public TestCase getEntity() { - return new TestCaseJpaController(getEntityManagerFactory()) - .findTestCase(getId()); - } - - @Override - public void update(TestCase target, TestCase source) { - target.setActive(source.getActive()); - target.setCreationDate(source.getCreationDate()); - target.setRiskControlHasTestCaseList(source - .getRiskControlHasTestCaseList()); - target.setStepList(source.getStepList() == null - ? new ArrayList<>() : source.getStepList()); - target.setIsOpen(source.getIsOpen()); - target.setSummary(source.getSummary()); - target.setTestPlanList(new ArrayList<>()); - target.setId(source.getId()); - target.setName(source.getName()); - target.setIsOpen(source.getIsOpen()); - } - - @Override - public void update() { - update(this, getEntity()); - } - - public Step addStep(int sequence, String text, String note, String criteria, - List requirements) - throws PreexistingEntityException, Exception { - StepServer ss = new StepServer(getEntity(), sequence, text); - int amount = getStepList().size(); - ss.setNotes(note); - ss.setExpectedResult(criteria.getBytes("UTF-8")); - if (ss.getRequirementList() == null) { - ss.setRequirementList(new ArrayList<>()); - } - ss.write2DB(); - if (requirements != null) { - requirements.forEach((req) -> { - ss.getRequirementList().add(req); - }); - } - ss.write2DB(); - update(); - assert getStepList().size() > amount; - return ss.getEntity(); - } -} +package com.validation.manager.core.server.core; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.db.Requirement; +import com.validation.manager.core.db.Step; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.controller.TestCaseJpaController; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class TestCaseServer extends TestCase + implements EntityServer { + + public TestCaseServer(int id) { + super(id); + update(); + } + + public TestCaseServer(TestCase tc) { + super.setId(tc.getId()); + update(); + } + + public TestCaseServer(String name, Date creationDate) { + super(name, creationDate); + } + + @Override + public int write2DB() throws IllegalOrphanException, + NonexistentEntityException, Exception { + TestCaseJpaController controller + = new TestCaseJpaController(getEntityManagerFactory()); + if (getId() != null && getId() > 0) { + TestCase temp = controller.findTestCase(getId()); + update(temp, this); + controller.edit(temp); + } else { + TestCase temp = new TestCase(getName(), getCreationDate()); + temp.setCreationDate(new Date()); + controller.create(temp); + setId(temp.getId()); + } + update(); + return getId(); + } + + @Override + public TestCase getEntity() { + return new TestCaseJpaController(getEntityManagerFactory()) + .findTestCase(getId()); + } + + @Override + public void update(TestCase target, TestCase source) { + target.setActive(source.getActive()); + target.setCreationDate(source.getCreationDate()); + target.setRiskControlHasTestCaseList(source + .getRiskControlHasTestCaseList()); + target.setStepList(source.getStepList() == null + ? new ArrayList<>() : source.getStepList()); + target.setIsOpen(source.getIsOpen()); + target.setSummary(source.getSummary()); + target.setTestPlanList(new ArrayList<>()); + target.setId(source.getId()); + target.setName(source.getName()); + target.setIsOpen(source.getIsOpen()); + } + + @Override + public void update() { + update(this, getEntity()); + } + + public Step addStep(int sequence, String text, String note, String criteria, + List requirements) + throws PreexistingEntityException, Exception { + StepServer ss = new StepServer(getEntity(), sequence, text); + int amount = getStepList().size(); + ss.setNotes(note); + ss.setExpectedResult(criteria.getBytes("UTF-8")); + if (ss.getRequirementList() == null) { + ss.setRequirementList(new ArrayList<>()); + } + ss.write2DB(); + if (requirements != null) { + requirements.forEach((req) -> { + ss.getRequirementList().add(req); + }); + } + ss.write2DB(); + update(); + assert getStepList().size() > amount; + return ss.getEntity(); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/TestPlanServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/TestPlanServer.java index bc5410ca..d5901e00 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/TestPlanServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/TestPlanServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,134 +13,135 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.Role; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.TestPlan; -import com.validation.manager.core.db.TestProject; -import com.validation.manager.core.db.UserTestPlanRole; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.TestPlanJpaController; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import java.util.ArrayList; -import java.util.Objects; -import java.util.logging.Level; -import java.util.logging.Logger; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class TestPlanServer extends TestPlan - implements EntityServer { - - private final static Logger LOG - = Logger.getLogger(TestPlanServer.class.getName()); - - public TestPlanServer(TestPlan plan) { - super.setTestPlanPK(plan.getTestPlanPK()); - update(); - } - - public TestPlanServer(TestProject testProject, boolean active, - boolean isOpen) { - super(testProject, active, isOpen); - setTestProject(testProject); - setTestPlanList(new ArrayList<>()); - setUserTestPlanRoleList(new ArrayList<>()); - setTestCaseList(new ArrayList<>()); - } - - @Override - public int write2DB() throws IllegalOrphanException, - NonexistentEntityException, Exception { - TestPlanJpaController controller - = new TestPlanJpaController(getEntityManagerFactory()); - if (getTestPlanPK().getId() > 0) { - TestPlan temp = controller.findTestPlan(getTestPlanPK()); - update(temp, this); - controller.edit(temp); - } else { - TestPlan temp = new TestPlan(getTestProject(), getActive(), - getIsOpen()); - update(temp, this); - controller.create(temp); - setTestPlanPK(temp.getTestPlanPK()); - } - return getTestPlanPK().getId(); - } - - public static boolean deleteTestPlan(TestPlan tp) { - try { - new TestPlanJpaController(getEntityManagerFactory()) - .destroy(tp.getTestPlanPK()); - } - catch (IllegalOrphanException | NonexistentEntityException ex) { - LOG.log(Level.SEVERE, null, ex); - return false; - } - return true; - } - - public boolean addTestCase(TestCase test) { - try { - getTestCaseList().add(test); - write2DB(); - return true; - } - catch (PreexistingEntityException ex) { - LOG.log(Level.SEVERE, null, ex); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - return false; - } - - @Override - public TestPlan getEntity() { - return new TestPlanJpaController(getEntityManagerFactory()) - .findTestPlan(getTestPlanPK()); - } - - @Override - public void update(TestPlan target, TestPlan source) { - target.setActive(source.getActive()); - target.setIsOpen(source.getIsOpen()); - target.setNotes(source.getNotes()); - target.setTestCaseList(source.getTestCaseList()); - target.setTestPlanList(source.getTestPlanList()); - target.setUserTestPlanRoleList(source.getUserTestPlanRoleList()); - target.setTestPlanPK(source.getTestPlanPK()); - target.setTestPlan(source.getTestPlan()); - target.setName(source.getName()); - } - - @Override - public void update() { - update(this, getEntity()); - } - - public void addUserTestPlanRole(VmUser user, Role role) throws Exception { - for (UserTestPlanRole utpr : getUserTestPlanRoleList()) { - if (utpr.getTestPlan().getTestPlanPK().equals(getTestPlanPK()) - && Objects.equals(utpr.getVmUser().getId(), user.getId()) - && Objects.equals(utpr.getRole().getId(), role.getId())) { - //We have already this role. - return; - } - } - UserTestPlanRoleServer temp = new UserTestPlanRoleServer(getEntity(), - user, role); - if (temp.getEntity() == null) { - temp.write2DB(); - } - getUserTestPlanRoleList().add(temp.getEntity()); - write2DB(); - } -} +package com.validation.manager.core.server.core; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.Role; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.TestPlan; +import com.validation.manager.core.db.TestProject; +import com.validation.manager.core.db.UserTestPlanRole; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.TestPlanJpaController; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.ArrayList; +import java.util.Objects; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class TestPlanServer extends TestPlan + implements EntityServer { + + private final static Logger LOG + = Logger.getLogger(TestPlanServer.class.getName()); + + public TestPlanServer(TestPlan plan) { + super.setTestPlanPK(plan.getTestPlanPK()); + update(); + } + + public TestPlanServer(TestProject testProject, boolean active, + boolean isOpen) { + super(testProject, active, isOpen); + setTestProject(testProject); + setTestPlanList(new ArrayList<>()); + setUserTestPlanRoleList(new ArrayList<>()); + setTestCaseList(new ArrayList<>()); + } + + @Override + public int write2DB() throws VMException { + try { + TestPlanJpaController controller + = new TestPlanJpaController(getEntityManagerFactory()); + if (getTestPlanPK().getId() > 0) { + TestPlan temp = controller.findTestPlan(getTestPlanPK()); + update(temp, this); + controller.edit(temp); + } else { + TestPlan temp = new TestPlan(getTestProject(), getActive(), + getIsOpen()); + update(temp, this); + controller.create(temp); + setTestPlanPK(temp.getTestPlanPK()); + } + } + catch (Exception ex) { + throw new VMException(ex); + } + return getTestPlanPK().getId(); + } + + public static boolean deleteTestPlan(TestPlan tp) { + try { + new TestPlanJpaController(getEntityManagerFactory()) + .destroy(tp.getTestPlanPK()); + } + catch (IllegalOrphanException | NonexistentEntityException ex) { + LOG.log(Level.SEVERE, null, ex); + return false; + } + return true; + } + + public boolean addTestCase(TestCase test) { + try { + getTestCaseList().add(test); + write2DB(); + return true; + } + catch (VMException ex) { + LOG.log(Level.SEVERE, null, ex); + } + return false; + } + + @Override + public TestPlan getEntity() { + return new TestPlanJpaController(getEntityManagerFactory()) + .findTestPlan(getTestPlanPK()); + } + + @Override + public void update(TestPlan target, TestPlan source) { + target.setActive(source.getActive()); + target.setIsOpen(source.getIsOpen()); + target.setNotes(source.getNotes()); + target.setTestCaseList(source.getTestCaseList()); + target.setTestPlanList(source.getTestPlanList()); + target.setUserTestPlanRoleList(source.getUserTestPlanRoleList()); + target.setTestPlanPK(source.getTestPlanPK()); + target.setTestPlan(source.getTestPlan()); + target.setName(source.getName()); + } + + @Override + public void update() { + update(this, getEntity()); + } + + public void addUserTestPlanRole(VmUser user, Role role) throws Exception { + for (UserTestPlanRole utpr : getUserTestPlanRoleList()) { + if (utpr.getTestPlan().getTestPlanPK().equals(getTestPlanPK()) + && Objects.equals(utpr.getVmUser().getId(), user.getId()) + && Objects.equals(utpr.getRole().getId(), role.getId())) { + //We have already this role. + return; + } + } + UserTestPlanRoleServer temp = new UserTestPlanRoleServer(getEntity(), + user, role); + if (temp.getEntity() == null) { + temp.write2DB(); + } + getUserTestPlanRoleList().add(temp.getEntity()); + write2DB(); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/TestProjectServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/TestProjectServer.java index 5ad3ca63..6e320d78 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/TestProjectServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/TestProjectServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,92 +13,100 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.Role; -import com.validation.manager.core.db.TestProject; -import com.validation.manager.core.db.UserTestProjectRole; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.TestProjectJpaController; -import com.validation.manager.core.db.controller.UserTestProjectRoleJpaController; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class TestProjectServer extends TestProject - implements EntityServer { - - public TestProjectServer(String name, boolean active) { - super(name, active); - } - - public TestProjectServer(TestProject tp) { - super.setId(tp.getId()); - update(); - } - - @Override - public int write2DB() throws IllegalOrphanException, - NonexistentEntityException, Exception { - TestProject tp; - if (getId() == null) { - tp = new TestProject(); - update(tp, this); - new TestProjectJpaController(getEntityManagerFactory()).create(tp); - setId(tp.getId()); - } else { - tp = getEntity(); - update(tp, this); - new TestProjectJpaController(getEntityManagerFactory()).edit(tp); - } - update(); - return getId(); - } - - @Override - public TestProject getEntity() { - return new TestProjectJpaController( - getEntityManagerFactory()) - .findTestProject(getId()); - } - - @Override - public void update(TestProject target, TestProject source) { - target.setActive(source.getActive()); - target.setName(source.getName()); - target.setNotes(source.getNotes()); - target.setId(source.getId()); - target.setProjectList(source.getProjectList()); - target.setTestPlanList(source.getTestPlanList()); - target.setUserTestProjectRoleList(source.getUserTestProjectRoleList()); - } - - @Override - public void update() { - update(this, getEntity()); - } - - public UserTestProjectRole addUserTestProjectRole(TestProject tp, VmUser user, Role role) - throws Exception { - UserTestProjectRole temp = new UserTestProjectRole(tp.getId(), - user.getId(), role.getId()); - temp.setVmUser(user); - temp.setRole(role); - temp.setTestProject(tp); - UserTestProjectRoleJpaController controller - = new UserTestProjectRoleJpaController(DataBaseManager - .getEntityManagerFactory()); - if (controller.findUserTestProjectRole(temp - .getUserTestProjectRolePK()) == null) { - controller.create(temp); - update(); - } - return temp; - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.Role; +import com.validation.manager.core.db.TestProject; +import com.validation.manager.core.db.UserTestProjectRole; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.TestProjectJpaController; +import com.validation.manager.core.db.controller.UserTestProjectRoleJpaController; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class TestProjectServer extends TestProject + implements EntityServer { + + public TestProjectServer(String name, boolean active) { + super(name, active); + } + + public TestProjectServer(int id) { + super.setId(id); + update(); + } + + public TestProjectServer(TestProject tp) { + super.setId(tp.getId()); + update(); + } + + @Override + public int write2DB() throws VMException { + try { + TestProject tp; + if (getId() == null) { + tp = new TestProject(); + update(tp, this); + new TestProjectJpaController(getEntityManagerFactory()).create(tp); + setId(tp.getId()); + } else { + tp = getEntity(); + update(tp, this); + new TestProjectJpaController(getEntityManagerFactory()).edit(tp); + } + update(); + } + catch (Exception ex) { + throw new VMException(ex); + } + return getId(); + } + + @Override + public TestProject getEntity() { + return new TestProjectJpaController( + getEntityManagerFactory()) + .findTestProject(getId()); + } + + @Override + public void update(TestProject target, TestProject source) { + target.setActive(source.getActive()); + target.setName(source.getName()); + target.setNotes(source.getNotes()); + target.setId(source.getId()); + target.setProjectList(source.getProjectList()); + target.setTestPlanList(source.getTestPlanList()); + target.setUserTestProjectRoleList(source.getUserTestProjectRoleList()); + } + + @Override + public void update() { + update(this, getEntity()); + } + + public UserTestProjectRole addUserTestProjectRole(TestProject tp, VmUser user, Role role) + throws Exception { + UserTestProjectRole temp = new UserTestProjectRole(tp.getId(), + user.getId(), role.getId()); + temp.setVmUser(user); + temp.setRole(role); + temp.setTestProject(tp); + UserTestProjectRoleJpaController controller + = new UserTestProjectRoleJpaController(DataBaseManager + .getEntityManagerFactory()); + if (controller.findUserTestProjectRole(temp + .getUserTestProjectRolePK()) == null) { + controller.create(temp); + update(); + } + return temp; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/UserTestPlanRoleServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/UserTestPlanRoleServer.java index a26daace..2bcfa4a3 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/UserTestPlanRoleServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/UserTestPlanRoleServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,81 +13,87 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.Role; -import com.validation.manager.core.db.TestPlan; -import com.validation.manager.core.db.UserTestPlanRole; -import com.validation.manager.core.db.UserTestPlanRolePK; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.UserTestPlanRoleJpaController; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import java.util.logging.Level; -import static java.util.logging.Logger.getLogger; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class UserTestPlanRoleServer extends UserTestPlanRole - implements EntityServer { - - public UserTestPlanRoleServer(TestPlan tpl, VmUser user, Role role) { - super(tpl, user, role); - } - - public UserTestPlanRoleServer(UserTestPlanRolePK pk) { - super.setUserTestPlanRolePK(pk); - update(); - } - - @Override - public int write2DB() throws NonexistentEntityException, Exception { - UserTestPlanRoleJpaController controller - = new UserTestPlanRoleJpaController(getEntityManagerFactory()); - if (controller.findUserTestPlanRole(getUserTestPlanRolePK()) == null) { - UserTestPlanRole temp = new UserTestPlanRole(getTestPlan(), getVmUser(), - getRole()); - update(temp, this); - controller.create(temp); - update(this, temp); - } - return getUserTestPlanRolePK().getTestPlanTestProjectId(); - } - - public static boolean deleteUserTestPlanRole(UserTestPlanRole utpr) { - try { - new UserTestPlanRoleJpaController( - getEntityManagerFactory()).destroy( - utpr.getUserTestPlanRolePK()); - } - catch (NonexistentEntityException ex) { - getLogger(UserTestPlanRoleServer.class.getName()) - .log(Level.SEVERE, null, ex); - return false; - } - return true; - } - - @Override - public UserTestPlanRole getEntity() { - return new UserTestPlanRoleJpaController( - getEntityManagerFactory()) - .findUserTestPlanRole(getUserTestPlanRolePK()); - } - - @Override - public void update(UserTestPlanRole target, UserTestPlanRole source) { - target.setRole(source.getRole()); - target.setTestPlan(source.getTestPlan()); - target.setVmUser(source.getVmUser()); - target.setUserTestPlanRolePK(source.getUserTestPlanRolePK()); - } - - @Override - public void update() { - update(this, getEntity()); - } -} +package com.validation.manager.core.server.core; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.Role; +import com.validation.manager.core.db.TestPlan; +import com.validation.manager.core.db.UserTestPlanRole; +import com.validation.manager.core.db.UserTestPlanRolePK; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.UserTestPlanRoleJpaController; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.logging.Level; +import static java.util.logging.Logger.getLogger; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class UserTestPlanRoleServer extends UserTestPlanRole + implements EntityServer { + + public UserTestPlanRoleServer(TestPlan tpl, VmUser user, Role role) { + super(tpl, user, role); + } + + public UserTestPlanRoleServer(UserTestPlanRolePK pk) { + super.setUserTestPlanRolePK(pk); + update(); + } + + @Override + public int write2DB() throws VMException { + try { + UserTestPlanRoleJpaController controller + = new UserTestPlanRoleJpaController(getEntityManagerFactory()); + if (controller.findUserTestPlanRole(getUserTestPlanRolePK()) == null) { + UserTestPlanRole temp = new UserTestPlanRole(getTestPlan(), getVmUser(), + getRole()); + update(temp, this); + controller.create(temp); + update(this, temp); + } + } + catch (Exception ex) { + throw new VMException(ex); + } + return getUserTestPlanRolePK().getTestPlanTestProjectId(); + } + + public static boolean deleteUserTestPlanRole(UserTestPlanRole utpr) { + try { + new UserTestPlanRoleJpaController( + getEntityManagerFactory()).destroy( + utpr.getUserTestPlanRolePK()); + } + catch (NonexistentEntityException ex) { + getLogger(UserTestPlanRoleServer.class.getName()) + .log(Level.SEVERE, null, ex); + return false; + } + return true; + } + + @Override + public UserTestPlanRole getEntity() { + return new UserTestPlanRoleJpaController( + getEntityManagerFactory()) + .findUserTestPlanRole(getUserTestPlanRolePK()); + } + + @Override + public void update(UserTestPlanRole target, UserTestPlanRole source) { + target.setRole(source.getRole()); + target.setTestPlan(source.getTestPlan()); + target.setVmUser(source.getVmUser()); + target.setUserTestPlanRolePK(source.getUserTestPlanRolePK()); + } + + @Override + public void update() { + update(this, getEntity()); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/UserTestProjectRoleServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/UserTestProjectRoleServer.java index 0f8ba306..2152c907 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/UserTestProjectRoleServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/UserTestProjectRoleServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,99 +13,100 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.UserTestProjectRole; -import com.validation.manager.core.db.controller.UserTestProjectRoleJpaController; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import java.util.logging.Level; -import static java.util.logging.Logger.getLogger; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class UserTestProjectRoleServer extends UserTestProjectRole - implements EntityServer { - - public UserTestProjectRoleServer(int testProjectId, int userId, int roleId) { - super(testProjectId, userId, roleId); - update(); - } - - /** - * Persist to database - * - * @throws PreexistingEntityException If entity already exists and tried to - * be re-created. - * @throws Exception If something goes wrong writing to the database. - */ - @Override - public int write2DB() throws PreexistingEntityException, Exception { - UserTestProjectRoleJpaController controller - = new UserTestProjectRoleJpaController(getEntityManagerFactory()); - if (getUserTestProjectRolePK().getRoleId() > 0 - && getUserTestProjectRolePK().getTestProjectId() > 0 - && getUserTestProjectRolePK().getUserId() > 0) { - UserTestProjectRole temp - = controller.findUserTestProjectRole(getUserTestProjectRolePK()); - temp.setRole(getRole()); - temp.setTestProject(getTestProject()); - temp.setVmUser(getVmUser()); - controller.edit(temp); - } else { - UserTestProjectRole temp = new UserTestProjectRole( - getUserTestProjectRolePK().getTestProjectId(), - getUserTestProjectRolePK().getUserId(), - getUserTestProjectRolePK().getRoleId()); - temp.setRole(getRole()); - temp.setTestProject(getTestProject()); - temp.setVmUser(getVmUser()); - controller.create(temp); - setUserTestProjectRolePK(temp.getUserTestProjectRolePK()); - } - return getUserTestProjectRolePK().getRoleId(); - } - - /** - * Delete UserTestProjectRole - * - * @param role UserTestProjectRole to delete - * @return true if successful - */ - public static boolean deleteUserTestProjectRole(UserTestProjectRole role) { - try { - new UserTestProjectRoleJpaController( - getEntityManagerFactory()).destroy( - role.getUserTestProjectRolePK()); - } - catch (NonexistentEntityException ex) { - getLogger(UserTestProjectRoleServer.class.getName()) - .log(Level.SEVERE, null, ex); - return false; - } - return true; - } - - @Override - public UserTestProjectRole getEntity() { - return new UserTestProjectRoleJpaController( - getEntityManagerFactory()) - .findUserTestProjectRole(getUserTestProjectRolePK()); - } - - @Override - public void update(UserTestProjectRole target, UserTestProjectRole source) { - target.setRole(source.getRole()); - target.setTestProject(source.getTestProject()); - target.setVmUser(source.getVmUser()); - } - - @Override - public void update() { - update(this, getEntity()); - } -} +package com.validation.manager.core.server.core; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.UserTestProjectRole; +import com.validation.manager.core.db.controller.UserTestProjectRoleJpaController; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import java.util.logging.Level; +import static java.util.logging.Logger.getLogger; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class UserTestProjectRoleServer extends UserTestProjectRole + implements EntityServer { + + public UserTestProjectRoleServer(int testProjectId, int userId, + int roleId) throws Exception { + super(testProjectId, userId, roleId); + setTestProject(new TestProjectServer(testProjectId).getEntity()); + setRole(new RoleServer(roleId).getEntity()); + setVmUser(new VMUserServer(userId).getEntity()); + } + + /** + * Persist to database + * + * @throws VMException If something goes wrong writing to the database. + */ + @Override + public int write2DB() throws VMException { + try { + UserTestProjectRoleJpaController controller + = new UserTestProjectRoleJpaController(getEntityManagerFactory()); + UserTestProjectRole temp + = controller.findUserTestProjectRole(getUserTestProjectRolePK()); + if (temp == null) { + temp = new UserTestProjectRole(); + update(temp, this); + controller.create(temp); + setUserTestProjectRolePK(temp.getUserTestProjectRolePK()); + } else { + temp.setRole(getRole()); + temp.setTestProject(getTestProject()); + temp.setVmUser(getVmUser()); + controller.edit(temp); + } + update(); + } + catch (Exception ex) { + throw new VMException(ex); + } + return getUserTestProjectRolePK().getRoleId(); + } + + /** + * Delete UserTestProjectRole + * + * @param role UserTestProjectRole to delete + * @return true if successful + */ + public static boolean deleteUserTestProjectRole(UserTestProjectRole role) { + try { + new UserTestProjectRoleJpaController( + getEntityManagerFactory()).destroy( + role.getUserTestProjectRolePK()); + } + catch (NonexistentEntityException ex) { + getLogger(UserTestProjectRoleServer.class.getName()) + .log(Level.SEVERE, null, ex); + return false; + } + return true; + } + + @Override + public UserTestProjectRole getEntity() { + return new UserTestProjectRoleJpaController( + getEntityManagerFactory()) + .findUserTestProjectRole(getUserTestProjectRolePK()); + } + + @Override + public void update(UserTestProjectRole target, UserTestProjectRole source) { + target.setRole(source.getRole()); + target.setTestProject(source.getTestProject()); + target.setVmUser(source.getVmUser()); + target.setUserTestProjectRolePK(source.getUserTestProjectRolePK()); + } + + @Override + public void update() { + update(this, getEntity()); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/core/VMUserServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/core/VMUserServer.java index dcf1a370..0068e0e2 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/core/VMUserServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/core/VMUserServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,545 +13,461 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import static com.validation.manager.core.DataBaseManager.createdQuery; -import static com.validation.manager.core.DataBaseManager.getEntityManager; -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import static com.validation.manager.core.DataBaseManager.namedQuery; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.VMException; -import com.validation.manager.core.db.CorrectiveAction; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.Notification; -import com.validation.manager.core.db.Role; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.TestCaseExecution; -import com.validation.manager.core.db.UserAssigment; -import com.validation.manager.core.db.UserHasInvestigation; -import com.validation.manager.core.db.UserModifiedRecord; -import com.validation.manager.core.db.UserTestPlanRole; -import com.validation.manager.core.db.UserTestProjectRole; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.CorrectiveActionJpaController; -import com.validation.manager.core.db.controller.ExecutionStepJpaController; -import com.validation.manager.core.db.controller.RoleJpaController; -import com.validation.manager.core.db.controller.UserAssigmentJpaController; -import com.validation.manager.core.db.controller.UserHasInvestigationJpaController; -import com.validation.manager.core.db.controller.UserModifiedRecordJpaController; -import com.validation.manager.core.db.controller.UserStatusJpaController; -import com.validation.manager.core.db.controller.UserTestPlanRoleJpaController; -import com.validation.manager.core.db.controller.UserTestProjectRoleJpaController; -import com.validation.manager.core.db.controller.VmUserJpaController; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import static com.validation.manager.core.server.core.VMSettingServer.getSetting; -import static com.validation.manager.core.tool.MD5.encrypt; -import static java.lang.System.currentTimeMillis; -import java.util.ArrayList; -import java.util.Calendar; -import static java.util.Calendar.getInstance; -import java.util.Date; -import java.util.List; -import static java.util.Locale.getDefault; -import java.util.logging.Level; -import static java.util.logging.Logger.getLogger; -import javax.persistence.EntityTransaction; -import org.openide.util.Exceptions; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class VMUserServer extends VmUser implements EntityServer { - - private static final long serialVersionUID = 1L; - private boolean hashPassword = true; - private boolean increaseAttempts = false; - private boolean change; - - public VMUserServer(VmUser vmu) { - super.setId(vmu.getId()); - update(); - //previously hashing the already hashed password - setHashPassword(false); - } - - //create user object and login - public VMUserServer(String attrUN, String attrUPW) throws Exception { - super(); - try { - List result = createdQuery( - "SELECT u FROM VmUser uu WHERE u.username='" // NOI18N - + attrUN + "' AND u.password='" + encrypt(attrUPW) - + "' AND u.userStatusId.id <> 2"); - //throw exception if no result found - if (result.isEmpty()) { - PARAMETERS.clear(); - PARAMETERS.put("username", attrUN); - result - = namedQuery("VmUser.findByUsername", - PARAMETERS); - //The username is valid but wrong password. Increase the login attempts. - if (result.size() > 0) { - increaseAttempts = true; - VmUser xcu = (VmUser) result.get(0); - setAttempts(xcu.getAttempts()); - write2DB(); - } - throw new Exception(); - } else { - VmUser vmu = (VmUser) result.get(0); - update(VMUserServer.this, vmu); - //previously hashing the already hashed password - setHashPassword(false); - int status = vmu.getUserStatusId().getId(); - if (status != 2) { - Calendar cal2 = getInstance(), - now = getInstance(); - cal2.setTime(vmu.getLastModified()); - long diffMillis = now.getTimeInMillis() - - cal2.getTimeInMillis(); - long diffDays = diffMillis / (24 * 60 * 60 * 1000); - long age = getSetting("password.aging") - .getIntVal(); - if (diffDays >= age) { - status = 4; - } else { - status = 1; - } - setAttempts(0); - } else { - setAttempts(vmu.getAttempts()); - } - setUserStatusId(new UserStatusJpaController( - getEntityManagerFactory()) - .findUserStatus(status)); - } - } - catch (Exception e) { - EntityTransaction transaction - = getEntityManager().getTransaction(); - if (transaction.isActive()) { - transaction.rollback(); - } - List result = createdQuery("SELECT u FROM VmUser u WHERE u.username='" - + attrUN + "' AND u.userStatusId.id <> 2"); - //increase number of attempts - if (!result.isEmpty()) { - VmUser vmu = (VmUser) result.get(0); - update(VMUserServer.this, vmu); - //Don't rehash the pasword! - setHashPassword(false); //Increase attempts after a unsuccessfull login. - setIncreaseAttempts(true); - setLastModified(vmu.getLastModified()); - setChange(false); - write2DB(); - } - } - } - -//create user object for data structures - public VMUserServer(int id) throws Exception { - super.setId(id); - update(); - //previously hashing the already hashed password - setHashPassword(false); - } - - public VMUserServer(String name, String password, String firstName, - String lastName, String email) throws Exception { - setId(0); - setUsername(name); - setPassword(password); - setFirstName(firstName); - setLastName(lastName); - setEmail(email); - setLocale(getDefault().toString()); - setUserStatusId(new UserStatusJpaController( - getEntityManagerFactory()).findUserStatus(1)); - setAttempts(0); - setLastModified(new java.sql.Timestamp(currentTimeMillis())); - setHashPassword(true); - } - -//create user object - public VMUserServer(String name, String password, String firstName, - String lastName, String email, int userStatusId, int attempts, - java.sql.Timestamp lastModified) throws Exception { - setUsername(name); - setPassword(password); - setFirstName(firstName); - setLastName(lastName); - setEmail(email); - setUserStatusId(new UserStatusJpaController( - getEntityManagerFactory()) - .findUserStatus(userStatusId)); - setAttempts(attempts); - setLastModified(lastModified); - setHashPassword(true); - } - - //write to db - @Override - public int write2DB() throws Exception { - Date date; - if (getUserStatusId().getId() == 4) { - //Changed from aged out to password changed. Clear status - setUserStatusId(new UserStatusJpaController( - getEntityManagerFactory()) - .findUserStatus(1)); - setAttempts(0); -// setReason("audit.user.account.aged"); - setChange(true); - } - //Increase login attempts - if (increaseAttempts) { - setAttempts(getAttempts() + 1); - increaseAttempts = false; - } - //Lock account if needed. Can't lock main admin. - if (getAttempts() - > getSetting("password.attempts").getIntVal() - && getId() > 1) { - setUserStatusId( - new UserStatusJpaController( - getEntityManagerFactory()).findUserStatus(2)); - } - VmUserJpaController controller - = new VmUserJpaController(getEntityManagerFactory()); - if (getId() > 0) { - if (isChange()) { -// setModifierId(getEntity()); - date = new Date(); - setLastModified(date); - setChange(false); - } else { - date = getLastModified(); - } - setLastModified(date); - //Sometimes password got re-hashed - String password; - if (isHashPassword()) { - password = encrypt(getPassword().replaceAll("'", "\\\\'")); - } else { - password = getPassword().replaceAll("'", "\\\\'"); - } - VmUser vmu = controller.findVmUser(getId()); - update(vmu, this); - vmu.setPassword(password); -// vmu.setReason(getReason() == null -// ? "audit.general.modified" : getReason()); -// vmu.setModificationTime(new Date()); - controller.edit(vmu); - } else { - VmUser vmu = new VmUser( - getUsername().replaceAll("'", "\\\\'"), getPassword(), - getEmail().replaceAll("'", "\\\\'"), - getFirstName().replaceAll("'", "\\\\'"), - getLastName().replaceAll("'", "\\\\'"), getLocale(), - getLastModified(), new UserStatusJpaController( - getEntityManagerFactory()) - .findUserStatus(1), getAttempts()); - update(vmu, this); - controller.create(vmu); - setId(vmu.getId()); - } - setChange(false); -// setReason(""); - return getId(); - } - -//create complete list of users - public static ArrayList getVMUsers() { - ArrayList coreUsers = new ArrayList<>(); - try { - List result = createdQuery( - "Select x from VMUser x order by x.username"); - result.forEach((o) -> { - coreUsers.add(new VMUserServer((VmUser) o)); - }); - } - catch (Exception e) { - coreUsers.clear(); - } - return coreUsers; - } - - public boolean isHashPassword() { - return hashPassword; - } - - public void setHashPassword(boolean hashPassword) { - this.hashPassword = hashPassword; - } - - public boolean isIncreaseAttempts() { - return increaseAttempts; - } - - public void setIncreaseAttempts(boolean increaseAttempts) { - this.increaseAttempts = increaseAttempts; - } - - public boolean isPasswordUsable(String newPass, boolean hash) { - boolean passwordIsUsable = true; - try { - //Now check if password is not the same as the current password - List result = createdQuery( - "Select x from VmUser x where x.id=" + getId() - + " and x.password='" - + (hash ? encrypt(newPass) : newPass) + "'"); - if (result.size() > 0) { - passwordIsUsable = false; - } else { - //Here we'll catch if the password have been used in the - //unusable period (use id in case the username was modified) - VMUserServer user = new VMUserServer(getId()); - for (History u : user.getHistoryModificationList()) { - //Now check the aging - long diff = currentTimeMillis() - - u.getModificationTime().getTime(); - if (diff / (1000 * 60 * 60 * 24) - > getSetting("password.unusable_period") - .getIntVal()) { - passwordIsUsable = false; - } - } - } - //--------------------------- - } - catch (Exception ex) { - passwordIsUsable = false; - } - return passwordIsUsable; - } - - public boolean isPasswordUsable(String newPass) { - return isPasswordUsable(newPass, true); - } - - private void setChange(boolean c) { - change = c; - } - - private boolean isChange() { - return change; - } - - public static void deleteUser(VmUser user) { - if (user != null) { - PARAMETERS.clear(); - PARAMETERS.put("id", user.getId()); - VmUser temp = (VmUser) namedQuery("VmUser.findById", - PARAMETERS).get(0); - try { - for (CorrectiveAction ca : temp.getCorrectiveActionList()) { - new CorrectiveActionJpaController( - getEntityManagerFactory()).destroy(ca.getId()); - } - for (Role r : temp.getRoleList()) { - new RoleJpaController( - getEntityManagerFactory()).destroy(r.getId()); - } - for (UserAssigment ua : temp.getUserAssigmentList()) { - new UserAssigmentJpaController( - getEntityManagerFactory()).destroy(ua.getUserAssigmentPK()); - } - for (UserAssigment ua : temp.getUserAssigmentList1()) { - new UserAssigmentJpaController( - getEntityManagerFactory()).destroy(ua.getUserAssigmentPK()); - } - for (UserHasInvestigation i : temp.getUserHasInvestigationList()) { - new UserHasInvestigationJpaController( - getEntityManagerFactory()).destroy(i.getUserHasInvestigationPK()); - } - for (UserModifiedRecord rc : temp.getUserModifiedRecordList()) { - new UserModifiedRecordJpaController( - getEntityManagerFactory()).destroy(rc.getUserModifiedRecordPK()); - } - for (UserTestPlanRole rc : temp.getUserTestPlanRoleList()) { - new UserTestPlanRoleJpaController( - getEntityManagerFactory()).destroy(rc.getUserTestPlanRolePK()); - } - for (UserTestProjectRole rc : temp.getUserTestProjectRoleList()) { - new UserTestProjectRoleJpaController( - getEntityManagerFactory()).destroy(rc.getUserTestProjectRolePK()); - } - PARAMETERS.clear(); - PARAMETERS.put("id", temp.getId()); - temp = (VmUser) namedQuery("VmUser.findById", - PARAMETERS).get(0); - new VmUserJpaController( - getEntityManagerFactory()).destroy(temp.getId()); - } - catch (NonexistentEntityException | IllegalOrphanException ex) { - getLogger(VMUserServer.class.getName()).log(Level.SEVERE, null, ex); - } - } - } - - /** - * Check user credentials. - * - * the password is already encrypted. Usually queries from within the server - * itself - * - * @param username User name - * @param password Password - * @param encrypt Password needs encrypting? - * @return true if valid - */ - public static boolean validCredentials(String username, - String password, boolean encrypt) { - try { - PARAMETERS.clear(); - PARAMETERS.put("username", username); - PARAMETERS.put("password", encrypt - ? encrypt(password.replaceAll("'", "\\\\'")) : password); - return !createdQuery("SELECT x FROM VmUser x " - + "WHERE x.username = :username and x.password = :password", - PARAMETERS).isEmpty(); - } - catch (VMException e) { - getLogger(VMUserServer.class.getName()).log(Level.SEVERE, null, e); - return false; - } - catch (Exception ex) { - getLogger(VMUserServer.class.getName()).log(Level.SEVERE, null, ex); - return false; - } - } - - public static VmUser getUser(String username, - String password, boolean encrypt) { - try { - PARAMETERS.clear(); - PARAMETERS.put("username", username); - PARAMETERS.put("password", encrypt - ? encrypt(password.replaceAll("'", "\\\\'")) : password); - if (validCredentials(username, password, encrypt)) { - return (VmUser) createdQuery("SELECT x FROM VmUser x " - + "WHERE x.username = :username and x.password = :password", - PARAMETERS).get(0); - } else { - return null; - } - } - catch (Exception ex) { - getLogger(VMUserServer.class.getName()).log(Level.SEVERE, null, ex); - return null; - - } - } - - @Override - public VmUser getEntity() { - return new VmUserJpaController( - getEntityManagerFactory()) - .findVmUser(getId()); - } - - @Override - public void update(VmUser target, VmUser source) { - target.setPassword(source.getPassword()); - target.setFirstName(source.getFirstName()); - target.setLastName(source.getLastName()); - target.setLocale(source.getLocale()); - target.setEmail(source.getEmail()); - target.setAttempts(source.getAttempts()); - target.setLastModified(source.getLastModified()); - target.setUserStatusId(source.getUserStatusId()); - target.setRoleList(source.getRoleList()); - target.setCorrectiveActionList(source.getCorrectiveActionList()); - target.setUserAssigmentList(source.getUserAssigmentList()); - target.setUserAssigmentList1(source.getUserAssigmentList1()); - target.setUserHasInvestigationList(source.getUserHasInvestigationList()); - target.setUsername(source.getUsername()); - target.setRootCauseList(source.getRootCauseList()); - target.setUserTestPlanRoleList(source.getUserTestPlanRoleList()); - target.setUserTestProjectRoleList(source.getUserTestProjectRoleList()); - target.setId(source.getId()); - if (target.getExecutionStepList() == null) { - target.setExecutionStepList(new ArrayList<>()); - } - if (source.getExecutionStepList() != null) { - target.setExecutionStepList(source.getExecutionStepList()); - } - if (target.getExecutionStepList1() == null) { - target.setExecutionStepList1(new ArrayList<>()); - } - if (source.getExecutionStepList1() != null) { - target.setExecutionStepList1(source.getExecutionStepList1()); - } - if (target.getExecutionStepHasIssueList() == null) { - target.setExecutionStepHasIssueList(new ArrayList<>()); - } - target.setExecutionStepList(source.getExecutionStepList()); - target.setExecutionStepList1(source.getExecutionStepList1()); - target.setExecutionStepHasIssueList(source.getExecutionStepHasIssueList()); - target.setNotificationList(source.getNotificationList()); - target.setNotificationList1(source.getNotificationList1()); -// super.update(target, source); - } - - @Override - public void update() { - update(this, getEntity()); - } - - public void assignTestCase(TestCaseExecution tce, TestCase tc, - VmUser assigner) { - try { - VMUserServer a = new VMUserServer(assigner); - ExecutionStepJpaController c - = new ExecutionStepJpaController(DataBaseManager - .getEntityManagerFactory()); - tc.getStepList().forEach((s) -> { - tce.getExecutionStepList().stream().filter((es) - -> (es.getStep().getStepPK().equals(s.getStepPK()))) - .forEachOrdered((es) -> { - try { - es.setAssignedTime(new Date()); - c.edit(es); - getExecutionStepList().add(es); - a.getExecutionStepList1().add(es); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - }); - }); - a.write2DB(); - write2DB(); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - } - - public void setAsAssigner(ExecutionStep es) throws Exception { - ExecutionStepServer ess = new ExecutionStepServer(es); - ess.setAssigner(getEntity()); - ess.write2DB(); - update(); - } - - @Override - public String toString() { - return getFirstName() + " " + getLastName(); - } - - public List getPendingNotifications() { - update(); - List pending = new ArrayList<>(); - getNotificationList().forEach(n -> { - if (n.getAcknowledgeDate() == null) { - pending.add(n); - } - }); - return pending; - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import static com.validation.manager.core.DataBaseManager.createdQuery; +import static com.validation.manager.core.DataBaseManager.getEntityManager; +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.Notification; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.TestCaseExecution; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.ExecutionStepJpaController; +import com.validation.manager.core.db.controller.UserStatusJpaController; +import com.validation.manager.core.db.controller.VmUserJpaController; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import static com.validation.manager.core.server.core.VMSettingServer.getSetting; +import static com.validation.manager.core.tool.MD5.encrypt; +import static java.lang.System.currentTimeMillis; +import java.util.ArrayList; +import java.util.Calendar; +import static java.util.Calendar.getInstance; +import java.util.Date; +import java.util.List; +import static java.util.Locale.getDefault; +import java.util.logging.Level; +import java.util.logging.Logger; +import javax.persistence.EntityTransaction; +import org.openide.util.Exceptions; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class VMUserServer extends VmUser implements EntityServer { + + private static final long serialVersionUID = 1L; + private boolean hashPassword = true; + private boolean increaseAttempts = false; + private static final Logger LOG + = Logger.getLogger(VMUserServer.class.getName()); + private static final String USERNAME = "username"; + private static final String PWD = "password"; + + public VMUserServer(VmUser vmu) { + super.setId(vmu.getId()); + if (getId() != null) { + update(); + } + //previously hashing the already hashed password + setHashPassword(false); + } + + //create user object and login + public VMUserServer(String attrUN, String attrUPW) throws VMException { + super(); + try { + PARAMETERS.clear(); + PARAMETERS.put(USERNAME, attrUN); + PARAMETERS.put(PWD, encrypt(attrUPW)); + List result = createdQuery( + "SELECT u FROM VmUser u WHERE u.username= :username"// NOI18N + + " AND u.password= :password AND u.userStatusId.id <> 2", + PARAMETERS); + //throw exception if no result found + if (result.isEmpty()) { + //The username is valid but wrong password. Increase the login attempts. + throw new VMException("general.login.invalid.message"); + } else { + VmUser vmu = (VmUser) result.get(0); + update(VMUserServer.this, vmu); + //previously hashing the already hashed password + setHashPassword(false); + int status = vmu.getUserStatusId().getId(); + if (status != 2) { + Calendar cal2 = getInstance(), + now = getInstance(); + History last = getHistoryList().get(getHistoryList().size() - 1); + cal2.setTime(last.getModificationTime()); + long diffMillis = now.getTimeInMillis() + - cal2.getTimeInMillis(); + long diffDays = diffMillis / (24 * 60 * 60 * 1_000); + long age = getSetting("password.aging") + .getIntVal(); + if (diffDays >= age) { + status = 4; + } else { + status = 1; + } + setAttempts(0); + } else { + setAttempts(vmu.getAttempts()); + } + setUserStatusId(new UserStatusJpaController( + getEntityManagerFactory()) + .findUserStatus(status)); + } + } + catch (VMException e) { + EntityTransaction transaction + = getEntityManager().getTransaction(); + if (transaction.isActive()) { + transaction.rollback(); + } + List result = createdQuery("SELECT u FROM VmUser u WHERE u.username='" + + attrUN + "' AND u.userStatusId.id <> 2"); + //increase number of attempts + if (!result.isEmpty()) { + VMUserServer vmu = new VMUserServer((VmUser) result.get(0)); + //Don't rehash the pasword! + vmu.setHashPassword(false); + vmu.setIncreaseAttempts(true);//Increase attempts after a unsuccessfull login. + vmu.write2DB(); + } + } + } + +//create user object for data structures + public VMUserServer(int id) throws Exception { + super.setId(id); + update(); + //previously hashing the already hashed password + setHashPassword(false); + } + + public VMUserServer(String name, String password, String firstName, + String lastName, String email) throws Exception { + setId(0); + setUsername(name); + setPassword(password); + setFirstName(firstName); + setLastName(lastName); + setEmail(email); + setLocale(getDefault().toString()); + setUserStatusId(new UserStatusJpaController( + getEntityManagerFactory()).findUserStatus(1)); + setAttempts(0); + setHashPassword(true); + } + + private void prepareToPersist() { + if (getUserStatusId() == null) { + setUserStatusId(new UserStatusJpaController( + getEntityManagerFactory()) + .findUserStatus(1)); + } + if (getUserStatusId().getId() == 4) { + //Changed from aged out to password changed. Clear status + setUserStatusId(new UserStatusJpaController( + getEntityManagerFactory()) + .findUserStatus(1)); + setAttempts(0); + setReason("audit.user.account.aged"); + } + //Increase login attempts + if (increaseAttempts) { + setAttempts(getAttempts() + 1); + increaseAttempts = false; + } + //Lock account if needed. Can't lock main admin. + if (getAttempts() + > getSetting("password.attempts").getIntVal() + && getId() > 1) { + setUserStatusId( + new UserStatusJpaController( + getEntityManagerFactory()).findUserStatus(4)); + } + } + + //write to db + @Override + public int write2DB() throws VMException { + VmUserJpaController controller + = new VmUserJpaController(getEntityManagerFactory()); + if (getId() != null && getId() > 0) { + prepareToPersist(); + try { + if (getModifierId() == 0) { + setModifierId(getEntity().getId()); + } + //Sometimes password got re-hashed + String password; + if (isHashPassword()) { + password = encrypt(getPassword().replaceAll("'", "\\\\'")); + setHashPassword(false); + } else { + password = getPassword().replaceAll("'", "\\\\'"); + } + VmUser vmu = getEntity(); + update(vmu, this); + vmu.setPassword(password); + vmu.setReason(getReason() == null + ? "audit.general.modified" : getReason()); + vmu.setModificationTime(new Date()); + vmu.updateHistory(); + controller.edit(vmu); + update(); + } + catch (NonexistentEntityException ex) { + throw new VMException(ex); + } + catch (Exception ex) { + throw new VMException(ex); + } + } else { + try { + prepareToPersist(); + String password; + if (isHashPassword()) { + password = encrypt(getPassword().replaceAll("'", "\\\\'")); + setHashPassword(false); + } else { + password = getPassword().replaceAll("'", "\\\\'"); + } + VmUser vmu = new VmUser( + getUsername().replaceAll("'", "\\\\'"), password, + getEmail().replaceAll("'", "\\\\'"), + getFirstName().replaceAll("'", "\\\\'"), + getLastName().replaceAll("'", "\\\\'"), getLocale(), + new UserStatusJpaController( + getEntityManagerFactory()) + .findUserStatus(1), getAttempts()); + vmu.updateHistory(); + controller.create(vmu); + setId(vmu.getId()); + } + catch (Exception ex) { + throw new VMException(ex); + } + } + setReason(""); + update(); + return getId(); + } + + //Create complete list of users + public static ArrayList getVMUsers() { + ArrayList coreUsers = new ArrayList<>(); + try { + List result = createdQuery( + "Select x from VmUser x order by x.username"); + result.forEach((o) -> { + coreUsers.add(new VMUserServer((VmUser) o)); + }); + } + catch (Exception e) { + coreUsers.clear(); + } + return coreUsers; + } + + public boolean isHashPassword() { + return hashPassword; + } + + public void setHashPassword(boolean hashPassword) { + this.hashPassword = hashPassword; + } + + public boolean isIncreaseAttempts() { + return increaseAttempts; + } + + public void setIncreaseAttempts(boolean increaseAttempts) { + this.increaseAttempts = increaseAttempts; + } + + public boolean isPasswordUsable(String newPass, boolean hash) { + boolean passwordIsUsable = true; + try { + //Now check if password is not the same as the current password + PARAMETERS.clear(); + PARAMETERS.put(USERNAME, getUsername()); + PARAMETERS.put(PWD, hash + ? encrypt(newPass.replaceAll("'", "\\\\'")) : newPass); + List result = createdQuery("SELECT x FROM VmUser x " + + "WHERE x.username = :username and x.password = :password", + PARAMETERS); + if (result.size() > 0) { + //Can't change to same password. + passwordIsUsable = false; + } else { + //Here we'll catch if the password have been used in the + //unusable period (use id in case the username was modified) + VMUserServer user = new VMUserServer(getId()); + for (History u : user.getHistoryList()) { + //Now check the aging + long diff = currentTimeMillis() + - u.getModificationTime().getTime(); + if (diff / (1_000 * 60 * 60 * 24) + > getSetting("password.unusable_period") + .getIntVal()) { + passwordIsUsable = false; + } + } + } + //--------------------------- + } + catch (Exception ex) { + passwordIsUsable = false; + } + return passwordIsUsable; + } + + public boolean isPasswordUsable(String newPass) { + return isPasswordUsable(newPass, true); + } + + /** + * Check user credentials. + * + * The password is already encrypted. Usually queries from within the server + * itself + * + * @param username User name + * @param password Password + * @param encrypt Password needs encrypting? + * @return true if valid + */ + protected static boolean validCredentials(String username, + String password, boolean encrypt) { + try { + PARAMETERS.clear(); + PARAMETERS.put(USERNAME, username); + PARAMETERS.put(PWD, encrypt + ? encrypt(password.replaceAll("'", "\\\\'")) : password); + return !createdQuery("SELECT x FROM VmUser x " + + "WHERE x.username = :username and x.password = :password", + PARAMETERS).isEmpty(); + } + catch (VMException e) { + LOG.log(Level.SEVERE, null, e); + return false; + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + return false; + } + } + + public static VmUser getUser(String username, + String password, boolean encrypt) { + try { + PARAMETERS.clear(); + PARAMETERS.put(USERNAME, username); + PARAMETERS.put(PWD, encrypt + ? encrypt(password.replaceAll("'", "\\\\'")) : password); + if (validCredentials(username, password, encrypt)) { + return (VmUser) createdQuery("SELECT x FROM VmUser x " + + "WHERE x.username = :username and x.password = :password", + PARAMETERS).get(0); + } else { + return null; + } + } + catch (VMException ex) { + LOG.log(Level.SEVERE, null, ex); + return null; + + } + } + + @Override + public VmUser getEntity() { + return new VmUserJpaController(getEntityManagerFactory()) + .findVmUser(getId()); + } + + @Override + public void update(VmUser target, VmUser source) { + target.setPassword(source.getPassword()); + target.setFirstName(source.getFirstName()); + target.setLastName(source.getLastName()); + target.setLocale(source.getLocale()); + target.setEmail(source.getEmail()); + target.setAttempts(source.getAttempts()); + target.setUserStatusId(source.getUserStatusId()); + target.setRoleList(source.getRoleList()); + target.setCorrectiveActionList(source.getCorrectiveActionList()); + target.setUserAssigmentList(source.getUserAssigmentList()); + target.setUserAssigmentList1(source.getUserAssigmentList1()); + target.setUserHasInvestigationList(source.getUserHasInvestigationList()); + target.setUsername(source.getUsername()); + target.setRootCauseList(source.getRootCauseList()); + target.setUserTestPlanRoleList(source.getUserTestPlanRoleList()); + target.setUserTestProjectRoleList(source.getUserTestProjectRoleList()); + target.setId(source.getId()); + target.setExecutionStepList(source.getExecutionStepList()); + target.setExecutionStepList1(source.getExecutionStepList1()); + target.setExecutionStepList(source.getExecutionStepList()); + target.setExecutionStepList1(source.getExecutionStepList1()); + target.setExecutionStepHasIssueList(source.getExecutionStepHasIssueList()); + target.setNotificationList(source.getNotificationList()); + target.setNotificationList1(source.getNotificationList1()); + target.setHistoryModificationList(source.getHistoryModificationList()); + super.update(target, source); + } + + @Override + public void update() { + update(this, getEntity()); + } + + public void assignTestCase(TestCaseExecution tce, TestCase tc, + VmUser assigner) { + try { + VMUserServer a = new VMUserServer(assigner); + ExecutionStepJpaController c + = new ExecutionStepJpaController(DataBaseManager + .getEntityManagerFactory()); + tc.getStepList().forEach((s) -> { + tce.getExecutionStepList().stream().filter((es) + -> (es.getStep().getStepPK().equals(s.getStepPK()))) + .forEachOrdered((es) -> { + try { + es.setAssignedTime(new Date()); + c.edit(es); + getExecutionStepList().add(es); + a.getExecutionStepList1().add(es); + } + catch (Exception ex) { + Exceptions.printStackTrace(ex); + } + }); + }); + a.write2DB(); + write2DB(); + } + catch (VMException ex) { + Exceptions.printStackTrace(ex); + } + } + + public void setAsAssigner(ExecutionStep es) throws Exception { + ExecutionStepServer ess = new ExecutionStepServer(es); + ess.setAssigner(getEntity()); + ess.write2DB(); + update(); + } + + @Override + public String toString() { + return getFirstName() + " " + getLastName(); + } + + public List getPendingNotifications() { + update(); + List pending = new ArrayList<>(); + getNotificationList().forEach(n -> { + if (n.getAcknowledgeDate() == null) { + pending.add(n); + } + }); + return pending; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/server/fmea/CauseServer.java b/VM-Core/src/main/java/com/validation/manager/core/server/fmea/CauseServer.java index 3c0beb7b..0e97a3ed 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/server/fmea/CauseServer.java +++ b/VM-Core/src/main/java/com/validation/manager/core/server/fmea/CauseServer.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,67 +13,73 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.fmea; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.EntityServer; -import com.validation.manager.core.db.Cause; -import com.validation.manager.core.db.controller.CauseJpaController; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class CauseServer extends Cause implements EntityServer { - - public CauseServer(String name, String description) { - super(name, description); - setId(0); - } - - @Override - public int write2DB() throws NonexistentEntityException, Exception { - if (getId() > 0) { - Cause c = new CauseJpaController( - getEntityManagerFactory()) - .findCause(getId()); - update(c, this); - new CauseJpaController( - getEntityManagerFactory()).edit(c); - } else { - Cause c = new Cause(); - update(c, this); - new CauseJpaController( - getEntityManagerFactory()).create(c); - setId(c.getId()); - } - return getId(); - } - - public static boolean deleteCause(Cause c) throws NonexistentEntityException { - new CauseJpaController( - getEntityManagerFactory()).destroy(c.getId()); - return true; - } - - @Override - public Cause getEntity() { - return new CauseJpaController( - getEntityManagerFactory()).findCause(getId()); - } - - @Override - public void update(Cause target, Cause source) { - target.setDescription(source.getDescription()); - target.setName(source.getName()); - if (source.getRiskItemList() != null) { - target.setRiskItemList(source.getRiskItemList()); - } - } - - @Override - public void update() { - update(this, getEntity()); - } -} +package com.validation.manager.core.server.fmea; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.EntityServer; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.Cause; +import com.validation.manager.core.db.controller.CauseJpaController; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class CauseServer extends Cause implements EntityServer { + + public CauseServer(String name, String description) { + super(name, description); + setId(0); + } + + @Override + public int write2DB() throws VMException { + try { + if (getId() > 0) { + Cause c = new CauseJpaController( + getEntityManagerFactory()) + .findCause(getId()); + update(c, this); + new CauseJpaController( + getEntityManagerFactory()).edit(c); + } else { + Cause c = new Cause(); + update(c, this); + new CauseJpaController( + getEntityManagerFactory()).create(c); + setId(c.getId()); + } + } + catch (Exception ex) { + throw new VMException(ex); + } + return getId(); + } + + public static boolean deleteCause(Cause c) throws NonexistentEntityException { + new CauseJpaController( + getEntityManagerFactory()).destroy(c.getId()); + return true; + } + + @Override + public Cause getEntity() { + return new CauseJpaController( + getEntityManagerFactory()).findCause(getId()); + } + + @Override + public void update(Cause target, Cause source) { + target.setDescription(source.getDescription()); + target.setName(source.getName()); + if (source.getRiskItemList() != null) { + target.setRiskItemList(source.getRiskItemList()); + } + } + + @Override + public void update() { + update(this, getEntity()); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/spi/email/EmailManager.java b/VM-Core/src/main/java/com/validation/manager/core/spi/email/EmailManager.java new file mode 100644 index 00000000..929b6c93 --- /dev/null +++ b/VM-Core/src/main/java/com/validation/manager/core/spi/email/EmailManager.java @@ -0,0 +1,94 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.spi.email; + +import com.validation.manager.core.api.email.IEmailManager; +import com.validation.manager.core.server.core.VMSettingServer; +import java.util.Date; +import java.util.Properties; +import javax.mail.Message; +import javax.mail.MessagingException; +import javax.mail.PasswordAuthentication; +import javax.mail.Session; +import javax.mail.Transport; +import javax.mail.internet.InternetAddress; +import javax.mail.internet.MimeMessage; +import org.openide.util.lookup.ServiceProvider; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@ServiceProvider(service = IEmailManager.class) +public class EmailManager implements IEmailManager { + + @Override + public void sendEmail(String to, String cc, String from, + String subject, String bodyText) throws MessagingException { + Properties props = new Properties(); + props.put("mail.smtp.host", + VMSettingServer.getSetting("mail.smtp.host").getStringVal()); + props.put("mail.smtp.auth", VMSettingServer.getSetting("mail.smtp.auth") + .getBoolVal().toString()); + props.put("mail.debug", "true"); + props.put("mail.smtp.starttls.enable", + VMSettingServer.getSetting("mail.smtp.starttls.enable") + .getBoolVal().toString()); + props.put("mail.smtp.port", "" + + VMSettingServer.getSetting("mail.smtp.port").getIntVal()); + props.put("mail.smtp.socketFactory.port", "" + + VMSettingServer.getSetting("mail.smtp.socketFactory.port").getIntVal()); + props.put("mail.smtp.socketFactory.class", + VMSettingServer.getSetting("mail.smtp.socketFactory.class") + .getStringVal()); + props.put("mail.smtp.socketFactory.fallback", + VMSettingServer.getSetting("mail.smtp.socketFactory.fallback") + .getBoolVal().toString()); + Session mailSession; + String username = VMSettingServer.getSetting("mail.auth.username") + .getStringVal(); + String password = VMSettingServer.getSetting("mail.auth.password") + .getStringVal(); + if (username != null) { + mailSession = Session.getInstance(props, new javax.mail.Authenticator() { + + @Override + protected PasswordAuthentication getPasswordAuthentication() { + return new PasswordAuthentication(username, password); + } + }); + } else { + mailSession = Session.getInstance(props); + } + mailSession.setDebug(true); // Enable the debug mode + + Message email = new MimeMessage(mailSession); + //--[ Set the FROM, TO, DATE and SUBJECT fields + email.setFrom(new InternetAddress(from)); + email.setRecipients(Message.RecipientType.TO, + InternetAddress.parse(to)); + email.setSentDate(new Date()); + email.setSubject(subject); + if (cc != null && !cc.isEmpty()) { + email.setRecipients(Message.RecipientType.CC, + InternetAddress.parse(cc)); + } + //--[ Create the body of the mail + email.setText(bodyText); + //--[ Ask the Transport class to send our mail message + Transport.send(email); + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/spi/internationalization/DefaultInternationalizationProvider.java b/VM-Core/src/main/java/com/validation/manager/core/spi/internationalization/DefaultInternationalizationProvider.java index 33e3d212..c534969f 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/spi/internationalization/DefaultInternationalizationProvider.java +++ b/VM-Core/src/main/java/com/validation/manager/core/spi/internationalization/DefaultInternationalizationProvider.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,63 +13,66 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.spi.internationalization; - -import com.validation.manager.core.api.internationalization.InternationalizationProvider; -import com.validation.manager.core.api.internationalization.LocaleListener; -import java.io.UnsupportedEncodingException; -import java.util.Locale; -import java.util.ResourceBundle; -import java.util.logging.Level; -import java.util.logging.Logger; -import org.openide.util.Lookup; -import org.openide.util.lookup.ServiceProvider; -import org.openide.util.lookup.ServiceProviders; - -@ServiceProviders({ - @ServiceProvider(service = InternationalizationProvider.class, position = 1) - ,@ServiceProvider(service = LocaleListener.class)}) -public class DefaultInternationalizationProvider - implements InternationalizationProvider { - - private ResourceBundle RB = ResourceBundle.getBundle( - "com.validation.manager.resources.VMMessages", Locale.getDefault()); - private static final Logger LOG - = Logger.getLogger(DefaultInternationalizationProvider.class - .getSimpleName()); - - @Override - public String translate(String mess) { - try { - if (RB.containsKey(mess)) { - return RB.containsKey(mess) ? new String(RB.getString(mess) - .getBytes("ISO-8859-1"), "UTF-8") : mess; - } else { - //Try to search on any other provider - for (InternationalizationProvider i - : Lookup.getDefault() - .lookupAll(InternationalizationProvider.class)) { - if (!(i instanceof DefaultInternationalizationProvider) - && i.getResourceBundle().containsKey(mess)) { - return i.translate(mess); - } - } - } - } - catch (UnsupportedEncodingException ex) { - LOG.log(Level.SEVERE, null, ex); - } - return mess; - } - - @Override - public void setlocale(Locale locale) { - RB = ResourceBundle.getBundle( - "com.validation.manager.resources.VMMessages", locale); - } - - @Override - public ResourceBundle getResourceBundle() { - return RB; - } -} +package com.validation.manager.core.spi.internationalization; + +import com.vaadin.ui.UI; +import com.validation.manager.core.VMUI; +import com.validation.manager.core.api.internationalization.InternationalizationProvider; +import com.validation.manager.core.server.core.VMUserServer; +import java.io.UnsupportedEncodingException; +import java.util.Locale; +import java.util.ResourceBundle; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.openide.util.Lookup; +import org.openide.util.lookup.ServiceProvider; + +@ServiceProvider(service = InternationalizationProvider.class, position = 1) +public class DefaultInternationalizationProvider + implements InternationalizationProvider { + + private static final Logger LOG + = Logger.getLogger(DefaultInternationalizationProvider.class + .getSimpleName()); + + @Override + public String translate(String mess) { + VMUI ui = (VMUI) UI.getCurrent(); + VMUserServer user = ui == null ? null : ui.getUser(); + return translate(mess, user == null ? Locale.getDefault() + : new Locale(user.getLocale())); + } + + @Override + public ResourceBundle getResourceBundle() { + return ResourceBundle.getBundle( + "com.validation.manager.resources.VMMessages"); + } + + @Override + public String translate(String mess, Locale locale) { + try { + ResourceBundle bundle = ResourceBundle.getBundle( + "com.validation.manager.resources.VMMessages", locale); + if (bundle.containsKey(mess)) { + return bundle.containsKey(mess) + ? new String(bundle.getString(mess) + .getBytes("ISO-8859-1"), "UTF-8") : mess; + } else { + //Try to search on any other provider + for (InternationalizationProvider i + : Lookup.getDefault() + .lookupAll(InternationalizationProvider.class)) { + if (!(i instanceof DefaultInternationalizationProvider) + && i.getResourceBundle().containsKey(mess)) { + return i.translate(mess); + } + } + } + } + catch (UnsupportedEncodingException ex) { + LOG.log(Level.SEVERE, null, ex); + } + return mess; + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/tool/MD5.java b/VM-Core/src/main/java/com/validation/manager/core/tool/MD5.java index 9f9b26cb..90f70f0d 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/tool/MD5.java +++ b/VM-Core/src/main/java/com/validation/manager/core/tool/MD5.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,45 +13,47 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.tool; - -import static java.lang.Integer.toHexString; -import java.security.MessageDigest; -import static java.security.MessageDigest.getInstance; -import java.security.NoSuchAlgorithmException; - -/** - * - * @author Javier A. Ortiz - */ -public class MD5 { - - private static String md5val = ""; - private static MessageDigest algorithm = null; - - private MD5() { - } - - public static String encrypt(String text) throws Exception { - try { - algorithm = getInstance("MD5"); - } catch (NoSuchAlgorithmException nsae) { - throw new Exception("Cannot find digest algorithm"); - } - byte[] defaultBytes = text.getBytes(); - algorithm.reset(); - algorithm.update(defaultBytes); - byte messageDigest[] = algorithm.digest(); - StringBuilder hexString = new StringBuilder(); - - for (int i = 0; i < messageDigest.length; i++) { - String hex = toHexString(0xFF & messageDigest[i]); - if (hex.length() == 1) { - hexString.append('0'); - } - hexString.append(hex); - } - md5val = hexString.toString(); - return md5val; - } -} +package com.validation.manager.core.tool; + +import com.validation.manager.core.VMException; +import static java.lang.Integer.toHexString; +import java.security.MessageDigest; +import static java.security.MessageDigest.getInstance; +import java.security.NoSuchAlgorithmException; + +/** + * + * @author Javier A. Ortiz + */ +public class MD5 { + + private static String md5val = ""; + private static MessageDigest algorithm = null; + + private MD5() { + } + + public static String encrypt(String text) throws VMException { + try { + algorithm = getInstance("MD5"); + } + catch (NoSuchAlgorithmException nsae) { + throw new VMException("Cannot find digest algorithm"); + } + byte[] defaultBytes = text.getBytes(); + algorithm.reset(); + algorithm.update(defaultBytes); + byte messageDigest[] = algorithm.digest(); + StringBuilder hexString = new StringBuilder(); + + for (int i = 0; i < messageDigest.length; i++) { + String hex = toHexString(0xFF & messageDigest[i]); + if (hex.length() == 1) { + hexString.append('0'); + } + hexString.append(hex); + } + md5val = hexString.toString(); + return md5val; + } +} diff --git a/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages.properties b/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages.properties index c2536ccf..b30c2289 100755 --- a/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages.properties +++ b/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages.properties @@ -1,12 +1,19 @@ add.attachment=Add Attachment -add.comment=Add comment +add.comment=Add Comment add.details=Add Details +add.user=Add User admin.desc=Administrator admin.tab.name=Administrator assign.test.case=Assign Test Case(s) assign.test.case.execution=Assign Test Case Execution attach.file=Attach File attachment.present=There are attachment present in the execution. +available.roles=Available Roles +current.roles=Current Roles +guest.desc=Guest +none.desc=None +reserved.desc=Reserved +requirement.manager.desc=Requirement Manager #Audit audit.coregroup.change=Core group changed\! audit.corenode.change=Core node changed\! @@ -54,7 +61,6 @@ date.format=Date Format #Delete delete.error=Unable to delete\! -delete.error\!=Unable to delete\! delete.execution=Delete Execution delete.with.issues.message=There are attachment(s), issue(s) and/or comment(s) present in the execution. delete.with.issues.title=Want to delete even with identified issues? @@ -103,15 +109,26 @@ general.assignment.date=Assignment Date general.attachment=Attachments general.audit.menu=Audit Trail Menu general.cancel=Cancel -general.comclusion=Conclusion +general.conclusion=Conclusion +general.configuration=Configuration general.comment=Comment general.comments=Comments general.conclusion=Conclusion general.create=Create general.creation.date=Created on +general.delete=Delete general.description=Description general.edit=Edit general.email=Email +general.email.enable=Email Enabled +general.email.from=From +general.email.to=To +general.email.send=Send +general.email.subject=Subject +general.email.message=Message +general.email.settings=Email Settings +general.email.settings.test=Test Email Settings +general.email.settings.test.success=Success! general.error.record.creation=Error creating record\! general.error.record.update=Error updating record\! general.execute=Execute @@ -141,6 +158,7 @@ general.notification=Notification general.notifications=Notifications general.obsolete=Obsolete general.open=Open +general.output=Output general.parent=Parent general.password=Password general.project=Project @@ -192,6 +210,7 @@ issue.invalid=Invalid issue.not.reproduceable=Not Reproducible issue.present=There are issues present in the execution. issue.type=Issue Type +issue.resolution=Issue Resolution leader.desc=Lead Tester linked.requirement=Linked Requirements lock.test.case.message=Locked test cases are committed and can no longer be modified.\\nIt would be equivalent to documenting in paper. @@ -245,7 +264,7 @@ message.requirement.import.missing.column=Not enough columns in data source (%c) message.requirement.import.success=Requirement import completed\! message.requirement.import.verify=Please review the requirements to be imported. message.requirement.status=Status -message.requirement.type=Requirement Type +requirement.type=Requirement Type message.section.dnd.invalid=Invalid to move section to this location\! message.spec.level=Specification Level message.step.create=Create Step @@ -277,6 +296,7 @@ notification.type=Notification Type notification.author=Author notification.mark.unread=Mark as Unread notification.archive=Archive Notification +notification.new=You received a new notification! modification.date=Modification Date observation.desc=Observation to be evaluated diff --git a/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_es.properties b/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_es.properties index 93b02cfc..f0feab70 100755 --- a/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_es.properties +++ b/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_es.properties @@ -68,7 +68,6 @@ message.requirement.import.invalid.product = Producto inválido provisto. message.requirement.import.file.null = Archivo para importar es nulo message.requirement.import.file.invalid = Archivo para importar no existe message.requirement.import.verify = Por favor revise los requicitos a importar. -message.requirement.type = Tipo de Requicito message.requirement.import.success = Importe de requicitos completado\! message.requirement.dnd.invalid = Mover requicitos a este lugar es inválido\! message.requirement.status = Estado @@ -183,6 +182,7 @@ issue.invalid = Inválido # Baseline baseline.creation = Creación de Línea de Base add.attachment = Añadir Archivo +# Fuzzy add.comment = Añadir comentario add.details = Añadir Detalles assign.test.case = Asignar Prueba(s) @@ -212,7 +212,6 @@ create.test.suite = Crear Grupo de Pruebas creation.time = Fecha de Creación # Delete delete.error = Fue imposible de eliminar\! -delete.error\! = \nFue imposible de eliminar\! delete.execution = Eliminar Ejecución delete.with.issues.message = Hay archivo(s), reporte(s) de problema y/o comentario(s) presentes en la ejecución. delete.with.issues.title = Quiere eliminar aún con los problemas identificados? @@ -246,7 +245,6 @@ general.active = Activo general.amount = Cantidad general.assignee = Usuario Asignado general.attachment = Archivos -general.comclusion = Conclusión general.comment = Comentario general.comments = Comentarios general.conclusion = Conclusión @@ -371,4 +369,26 @@ notification.mark.unread = Marcar como no leído notification.archive = Archivar Notificación general.archived = Archivado general.no = No -general.yes = Si \ No newline at end of file +general.yes = Si +general.email.enable = Correo Electrónico Activado +general.email.from = De +general.email.to = Hacia +general.email.send = Enviar +general.email.subject = Título +general.email.message = Mensaje +general.email.settings = Configuración de Correo Electrónico +general.email.settings.test = Probar Configuraciones de Correo Electrónico +general.email.settings.test.success = Exito +general.output = Salida +notification.new = Has recibido una nueva notificación\! +add.user = Añadir usuario +available.roles = Roles Disponibles +current.roles = Roles Actuales +guest.desc = Invitado +none.desc = Ninguno +reserved.desc = Reservado +requirement.manager.desc = Manejador de Requicitos +general.configuration = Configuración +general.delete = Eliminar +issue.resolution = Resolución del Problema +requirement.type = Tipo de Requicito \ No newline at end of file diff --git a/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_fr_FR.properties b/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_fr_FR.properties index ba21db36..c5e7e80c 100755 --- a/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_fr_FR.properties +++ b/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_fr_FR.properties @@ -52,7 +52,6 @@ creation.time=Creation Time #Delete delete.error=Unable to delete\! -delete.error\!=Unable to delete\! delete.execution=Delete Execution delete.with.issues.message=There are attachment(s), issue(s) and/or comment(s) present in the execution. delete.with.issues.title=Want to delete even with identified issues? @@ -100,7 +99,7 @@ general.assignment.date=Assignment Date general.attachment=Attachments general.audit.menu=Audit Trail Menu general.cancel=Cancel -general.comclusion=Conclusion +general.conclusion=Conclusion general.comment=Comment general.comments=Comments general.conclusion=Conclusion @@ -233,7 +232,7 @@ message.requirement.import.missing.column=Not enough columns in data source (%c) message.requirement.import.success=Requirement import completed\! message.requirement.import.verify=Please review the requirements to be imported. message.requirement.status=Status -message.requirement.type=Requirement Type +requirement.type=Requirement Type message.section.dnd.invalid=Invalid to move section to this location\! message.spec.level=Specification Level message.step.create=Create Step diff --git a/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_zh_CN.properties b/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_zh_CN.properties index ba21db36..c5e7e80c 100755 --- a/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_zh_CN.properties +++ b/VM-Core/src/main/resources/com/validation/manager/resources/VMMessages_zh_CN.properties @@ -52,7 +52,6 @@ creation.time=Creation Time #Delete delete.error=Unable to delete\! -delete.error\!=Unable to delete\! delete.execution=Delete Execution delete.with.issues.message=There are attachment(s), issue(s) and/or comment(s) present in the execution. delete.with.issues.title=Want to delete even with identified issues? @@ -100,7 +99,7 @@ general.assignment.date=Assignment Date general.attachment=Attachments general.audit.menu=Audit Trail Menu general.cancel=Cancel -general.comclusion=Conclusion +general.conclusion=Conclusion general.comment=Comment general.comments=Comments general.conclusion=Conclusion @@ -233,7 +232,7 @@ message.requirement.import.missing.column=Not enough columns in data source (%c) message.requirement.import.success=Requirement import completed\! message.requirement.import.verify=Please review the requirements to be imported. message.requirement.status=Status -message.requirement.type=Requirement Type +requirement.type=Requirement Type message.section.dnd.invalid=Invalid to move section to this location\! message.spec.level=Specification Level message.step.create=Create Step diff --git a/VM-Core/src/main/resources/db/migration/V1_4__New_Setings.sql b/VM-Core/src/main/resources/db/migration/V1_4__New_Setings.sql new file mode 100644 index 00000000..1765c2fb --- /dev/null +++ b/VM-Core/src/main/resources/db/migration/V1_4__New_Setings.sql @@ -0,0 +1,14 @@ +/*Add settings*/ +INSERT INTO `vm_setting` (`id`, `setting`, `bool_val`, `int_val`, `long_val`, `string_val`) VALUES (13, 'mail.smtp.host', 0, 0, '0', 'smtp.gmail.com'); +INSERT INTO `vm_setting` (`id`, `setting`, `bool_val`, `int_val`, `long_val`, `string_val`) VALUES (14, 'mail.smtp.socketFactory.class', 0, 0, '0', 'javax.net.ssl.SSLSocketFactory'); +INSERT INTO `vm_setting` (`id`, `setting`, `bool_val`, `int_val`, `long_val`, `string_val`) VALUES (15, 'mail.smtp.socketFactory.fallback', 0, 0, '0', NULL);/*False*/ +INSERT INTO `vm_setting` (`id`, `setting`, `bool_val`, `int_val`, `long_val`, `string_val`) VALUES (16, 'mail.smtp.port', 0, 465, '0', NULL);/*Gmail as default*/ +INSERT INTO `vm_setting` (`id`, `setting`, `bool_val`, `int_val`, `long_val`, `string_val`) VALUES (17, 'mail.smtp.socketFactory.port', 0, 465, '0', NULL); +INSERT INTO `vm_setting` (`id`, `setting`, `bool_val`, `int_val`, `long_val`, `string_val`) VALUES (18, 'mail.smtp.auth', 1, 0, '0', NULL); +INSERT INTO `vm_setting` (`id`, `setting`, `bool_val`, `int_val`, `long_val`, `string_val`) VALUES (19, 'mail.smtp.quitwait', 0, 0, '0', NULL);/*False*/ +INSERT INTO `vm_setting` (`id`, `setting`, `bool_val`, `int_val`, `long_val`, `string_val`) VALUES (20, 'mail.smtp.starttls.enable', 1, 0, '0', NULL); +INSERT INTO `vm_setting` (`id`, `setting`, `bool_val`, `int_val`, `long_val`, `string_val`) VALUES (21, 'mail.auth.username', 1, 0, '0', NULL); +INSERT INTO `vm_setting` (`id`, `setting`, `bool_val`, `int_val`, `long_val`, `string_val`) VALUES (22, 'mail.auth.password', 1, 0, '0', NULL); +INSERT INTO `vm_setting` (`id`, `setting`, `bool_val`, `int_val`, `long_val`, `string_val`) VALUES (23, 'mail.enable', 0, 0, '0', NULL); +/*Fix typos*/ +UPDATE `role` set description = 'reserved.desc' where id in (1,2); \ No newline at end of file diff --git a/VM-Core/src/test/java/com/validation/manager/core/api/email/IEmailManagerTest.java b/VM-Core/src/test/java/com/validation/manager/core/api/email/IEmailManagerTest.java new file mode 100644 index 00000000..3a47fd54 --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/api/email/IEmailManagerTest.java @@ -0,0 +1,79 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.api.email; + +import com.validation.manager.test.AbstractVMTestCase; +import de.saly.javamail.mock2.MockMailbox; +import java.util.Arrays; +import javax.mail.Message; +import org.junit.Test; +import org.openide.util.Lookup; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class IEmailManagerTest extends AbstractVMTestCase { + + /** + * Test of sendEmail method, of class IEmailManager. + * + * @throws java.lang.Exception + */ + @Test + public void testSendEmail() throws Exception { + System.out.println("sendEmail"); + String to = "target@test.com"; + String cc = "cc@test.com"; + String from = "from@test.com"; + String subject = "Sample Email"; + String bodyText = "Hello World!"; + //Setup mock email server + MockMailbox toMailbox = MockMailbox.get(to); + MockMailbox ccMailbox = MockMailbox.get(cc); + MockMailbox fromMailbox = MockMailbox.get(from); + assertEquals(0, toMailbox.getInbox().getMessageCount()); + assertEquals(0, ccMailbox.getInbox().getMessageCount()); + assertEquals(0, fromMailbox.getInbox().getMessageCount()); + IEmailManager instance = Lookup.getDefault().lookup(IEmailManager.class); + instance.sendEmail(to, cc, from, subject, bodyText); + assertEquals(1, toMailbox.getInbox().getMessageCount()); + for (Message m : toMailbox.getInbox().getMessages()) { + System.out.println(m.getMessageNumber()); + System.out.println("From: " + Arrays.toString(m.getFrom())); + assertEquals(1, m.getFrom().length); + assertEquals(from, m.getFrom()[0].toString()); + System.out.println("Sent: " + m.getSentDate()); + System.out.println(m.getSubject()); + assertEquals(subject, m.getSubject()); + System.out.println(m.getContent()); + assertEquals(bodyText, m.getContent()); + } + assertEquals(1, ccMailbox.getInbox().getMessageCount()); + for (Message m : ccMailbox.getInbox().getMessages()) { + System.out.println(m.getMessageNumber()); + System.out.println("From: " + Arrays.toString(m.getFrom())); + assertEquals(1, m.getFrom().length); + assertEquals(from, m.getFrom()[0].toString()); + System.out.println("Sent: " + m.getSentDate()); + System.out.println(m.getSubject()); + assertEquals(subject, m.getSubject()); + System.out.println(m.getContent()); + assertEquals(bodyText, m.getContent()); + } + assertEquals(0, fromMailbox.getInbox().getMessageCount()); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/api/internationalization/InternationalizationProviderTest.java b/VM-Core/src/test/java/com/validation/manager/core/api/internationalization/InternationalizationProviderTest.java new file mode 100644 index 00000000..4f9e90bf --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/api/internationalization/InternationalizationProviderTest.java @@ -0,0 +1,65 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.api.internationalization; + +import java.util.Locale; +import static junit.framework.TestCase.*; +import org.junit.Test; +import org.openide.util.Lookup; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class InternationalizationProviderTest { + + /** + * Test of translate method, of class InternationalizationProvider. + */ + @Test + public void testTranslate_String() { + System.out.println("translate"); + String mess = "general.active"; + InternationalizationProvider instance + = Lookup.getDefault().lookup(InternationalizationProvider.class); + assertNotNull(instance.translate(mess)); + } + + /** + * Test of translate method, of class InternationalizationProvider. + */ + @Test + public void testTranslate_String_Locale() { + System.out.println("translate"); + String mess = "general.active"; + Locale l = new Locale("es"); + InternationalizationProvider instance + = Lookup.getDefault().lookup(InternationalizationProvider.class); + assertNotNull(instance.translate(mess, l)); + assertNotSame(instance.translate(mess), instance.translate(mess, l)); + } + + /** + * Test of getResourceBundle method, of class InternationalizationProvider. + */ + @Test + public void testGetResourceBundle() { + System.out.println("getResourceBundle"); + InternationalizationProvider instance + = Lookup.getDefault().lookup(InternationalizationProvider.class); + assertNotNull(instance.getResourceBundle()); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/db/ProjectTest.java b/VM-Core/src/test/java/com/validation/manager/core/db/ProjectTest.java index 45820285..52caed5a 100755 --- a/VM-Core/src/test/java/com/validation/manager/core/db/ProjectTest.java +++ b/VM-Core/src/test/java/com/validation/manager/core/db/ProjectTest.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,119 +13,110 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.VMException; -import com.validation.manager.core.db.controller.ProjectJpaController; -import com.validation.manager.core.server.core.ProjectServer; -import static com.validation.manager.core.server.core.ProjectServer.deleteProject; -import com.validation.manager.core.server.core.StepServer; -import com.validation.manager.core.server.core.TestCaseServer; -import com.validation.manager.core.tool.Tool; -import com.validation.manager.test.AbstractVMTestCase; -import static com.validation.manager.test.TestHelper.addRequirementToStep; -import static com.validation.manager.test.TestHelper.addStep; -import static com.validation.manager.test.TestHelper.addTestCaseToPlan; -import static com.validation.manager.test.TestHelper.createProject; -import static com.validation.manager.test.TestHelper.createRequirement; -import static com.validation.manager.test.TestHelper.createRequirementSpec; -import static com.validation.manager.test.TestHelper.createRequirementSpecNode; -import static com.validation.manager.test.TestHelper.createTestCase; -import static com.validation.manager.test.TestHelper.createTestPlan; -import static com.validation.manager.test.TestHelper.createTestProject; -import java.text.MessageFormat; -import java.util.logging.Level; -import java.util.logging.Logger; -import static java.util.logging.Logger.getLogger; -import static junit.framework.TestCase.assertEquals; -import org.junit.After; -import org.junit.Test; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class ProjectTest extends AbstractVMTestCase { - - private Project p; - private static final Logger LOG - = getLogger(ProjectTest.class.getName()); - - @After - public void clear() { - if (p != null) { - try { - deleteProject(p); - } - catch (VMException ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - } - - /** - * Test of toString method, of class Project. - */ - @Test - public void testCreateAndDestroy() { - try { - p = createProject("New Project", "Notes"); - assertEquals(0, Tool.extractRequirements(p).size()); - ProjectServer project = new ProjectServer(p); - project.setNotes("Notes 2"); - project.write2DB(); - Project temp = new ProjectJpaController( - getEntityManagerFactory()) - .findProject(project.getId()); - assertTrue(temp.getNotes().equals(project.getNotes())); - //Create requirements - LOG.info("Create Requirement Spec"); - RequirementSpec rss = null; - try { - rss = createRequirementSpec("Test", "Test", - project, 1); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - LOG.info("Create Requirement Spec Node"); - RequirementSpecNode rsns = null; - try { - rsns = createRequirementSpecNode( - rss, "Test", "Test", "Test"); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - Requirement r = createRequirement("SRS-SW-0001", - "Sample requirement", rsns.getRequirementSpecNodePK(), - "Notes", 1, 1); - //Create Test Case - TestCase tc = createTestCase("Dummy", "Summary"); - //Add steps - for (int i = 1; i < 6; i++) { - LOG.info(MessageFormat.format("Adding step: {0}", i)); - tc = addStep(tc, i, "Step " + i, "Note " + i, "Result " + i); - Step step = tc.getStepList().get(i - 1); - addRequirementToStep(step, r); - new TestCaseServer(tc).write2DB(); - assertEquals(1, new StepServer(step).getRequirementList().size()); - } - //Create test Project - TestProject tp = createTestProject("Test Project"); - //Create test plan - TestPlan plan = createTestPlan(tp, "Notes", true, true); - //Add test to plan - addTestCaseToPlan(plan, tc); - project.write2DB(); - assertEquals(1, Tool.extractRequirements(project.getEntity()).size()); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - } -} +package com.validation.manager.core.db; + +import com.validation.manager.core.DataBaseManager; +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.db.controller.ProjectJpaController; +import com.validation.manager.core.db.controller.TestPlanJpaController; +import com.validation.manager.core.server.core.ProjectServer; +import com.validation.manager.core.server.core.StepServer; +import com.validation.manager.core.server.core.TestCaseServer; +import com.validation.manager.core.server.core.TestPlanServer; +import com.validation.manager.core.tool.Tool; +import com.validation.manager.test.AbstractVMTestCase; +import static com.validation.manager.test.TestHelper.addRequirementToStep; +import static com.validation.manager.test.TestHelper.addStep; +import static com.validation.manager.test.TestHelper.addTestCaseToPlan; +import static com.validation.manager.test.TestHelper.createProject; +import static com.validation.manager.test.TestHelper.createRequirement; +import static com.validation.manager.test.TestHelper.createRequirementSpec; +import static com.validation.manager.test.TestHelper.createRequirementSpecNode; +import static com.validation.manager.test.TestHelper.createTestCase; +import static com.validation.manager.test.TestHelper.createTestPlan; +import static com.validation.manager.test.TestHelper.createTestProject; +import java.text.MessageFormat; +import java.util.logging.Level; +import java.util.logging.Logger; +import static java.util.logging.Logger.getLogger; +import static junit.framework.TestCase.assertEquals; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ProjectTest extends AbstractVMTestCase { + + private Project p; + private static final Logger LOG + = getLogger(ProjectTest.class.getName()); + + /** + * Test of toString method, of class Project. + */ + @Test + public void testCreateAndDestroy() { + try { + p = createProject("New Project", "Notes"); + assertEquals(0, Tool.extractRequirements(p).size()); + ProjectServer project = new ProjectServer(p); + project.setNotes("Notes 2"); + project.write2DB(); + Project temp = new ProjectJpaController( + getEntityManagerFactory()) + .findProject(project.getId()); + assertTrue(temp.getNotes().equals(project.getNotes())); + //Create requirements + LOG.info("Create Requirement Spec"); + RequirementSpec rss = null; + try { + rss = createRequirementSpec("Test", "Test", + project, 1); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + LOG.info("Create Requirement Spec Node"); + RequirementSpecNode rsns; + try { + rsns = createRequirementSpecNode( + rss, "Test", "Test", "Test"); + Requirement r = createRequirement("SRS-SW-0001", + "Sample requirement", rsns.getRequirementSpecNodePK(), + "Notes", 1, 1); + //Create Test Case + TestCase tc = createTestCase("Dummy", "Summary"); + //Add steps + for (int i = 1; i < 6; i++) { + LOG.info(MessageFormat.format("Adding step: {0}", i)); + tc = addStep(tc, i, "Step " + i, "Note " + i, "Result " + i); + Step step = tc.getStepList().get(i - 1); + addRequirementToStep(step, r); + new TestCaseServer(tc).write2DB(); + assertEquals(1, new StepServer(step).getRequirementList().size()); + } + //Create test Project + TestProject tp = createTestProject("Test Project"); + //Create test plan + TestPlan plan = createTestPlan(tp, "Notes", true, true); + //Add test to plan + addTestCaseToPlan(plan, tc); + project.write2DB(); + assertEquals(1, Tool.extractRequirements(project.getEntity()).size()); + TestPlanServer.deleteTestPlan(plan); + assertNull(new TestPlanJpaController(DataBaseManager + .getEntityManagerFactory()).findTestPlan(plan.getTestPlanPK())); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/db/RequirementHierarchyTest.java b/VM-Core/src/test/java/com/validation/manager/core/db/RequirementHierarchyTest.java index a65b802d..3e6f1ac0 100755 --- a/VM-Core/src/test/java/com/validation/manager/core/db/RequirementHierarchyTest.java +++ b/VM-Core/src/test/java/com/validation/manager/core/db/RequirementHierarchyTest.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,175 +13,180 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.db.controller.RequirementJpaController; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.server.core.ProjectServer; -import com.validation.manager.core.server.core.RequirementServer; -import com.validation.manager.core.server.core.RequirementSpecNodeServer; -import com.validation.manager.core.server.core.RequirementSpecServer; -import com.validation.manager.core.server.core.SpecLevelServer; -import com.validation.manager.test.AbstractVMTestCase; -import com.validation.manager.test.TestHelper; -import static com.validation.manager.test.TestHelper.createRequirement; -import static com.validation.manager.test.TestHelper.createRequirementSpecNode; -import java.util.ArrayList; -import java.util.List; -import java.util.logging.Level; -import java.util.logging.Logger; -import static java.util.logging.Logger.getLogger; -import org.junit.Test; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RequirementHierarchyTest extends AbstractVMTestCase { - - private static final Logger LOG - = getLogger(RequirementHierarchyTest.class.getName()); - private ProjectServer project; - - @Test - public void testHierarchy() { - System.out.println("Test Requirement Hierarchy"); - System.out.println("Create Project"); - project = new ProjectServer("Test product", "Project Notes"); - try { - project.write2DB(); - } catch (IllegalOrphanException ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } catch (NonexistentEntityException ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - System.out.println("Create Requirement Spec"); - RequirementSpec rss = null; - try { - rss = TestHelper.createRequirementSpec("Test", "Test", - project, 1); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - System.out.println("Create Requirement Spec Node"); - RequirementSpecNode rsns = null; - try { - rsns = createRequirementSpecNode( - rss, "Test", "Test", "Test"); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - System.out.println("Create Requirements"); - List requirements = new ArrayList<>(); - int requirementAmount = 15; - for (int i = 0; i < requirementAmount; i++) { - try { - Requirement reqs - = createRequirement("SRS-SW-00" + i, - "Description " + i, - rsns.getRequirementSpecNodePK(), - "Notes " + i, 2, 1); - requirements.add(new RequirementJpaController( - getEntityManagerFactory()) - .findRequirement(reqs.getId())); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - } - System.out.println("Done!"); - System.out.println("Create Requirement Spec Levels"); - SpecLevelServer userSpecLevel = createSpecLevel("User Requirement"); - SpecLevelServer functionalSpecLevel - = createSpecLevel("Functional Requirement"); - SpecLevelServer unitSpecLevel = createSpecLevel("Unit Requirement"); - System.out.println("Done!"); - System.out.println("Create Requirement Specs"); - RequirementSpecServer productSpec = createRequirementSpec( - "Project Spec", userSpecLevel); - RequirementSpecServer archSpec = createRequirementSpec( - "Architectural Spec", functionalSpecLevel); - RequirementSpecServer swSpec = createRequirementSpec( - "Software Spec", unitSpecLevel); - System.out.println("Done!"); - System.out.println("Adding requirements to spec nodes"); - try { - RequirementSpecNodeServer n1 - = productSpec.addSpecNode("Node 1", "description", "scope"); - requirements.subList(0, 5).forEach((r) -> { - n1.getRequirementList().add(r); - }); - n1.write2DB(); - assertEquals(1, productSpec.getRequirementSpecNodeList().size()); - RequirementSpecNodeServer n2 - = archSpec.addSpecNode("Node 2", "description", "scope"); - requirements.subList(5, 10).forEach((r) -> { - n2.getRequirementList().add(r); - }); - n2.write2DB(); - assertEquals(1, archSpec.getRequirementSpecNodeList().size()); - RequirementSpecNodeServer n3 - = swSpec.addSpecNode("Node 3", "description", "scope"); - requirements.subList(10, 15).forEach((r) -> { - n3.getRequirementList().add(r); - }); - n3.write2DB(); - assertEquals(1, swSpec.getRequirementSpecNodeList().size()); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - System.out.println("Done!"); - System.out.println("Adding requirements to requirements"); - int count = 0; - for (Requirement req : requirements) { - try { - req.getRequirementList().add(requirements.get(requirementAmount - count - 1)); - new RequirementServer(req).write2DB(); - count++; - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - } - System.out.println("Done!"); - } - - private SpecLevelServer createSpecLevel(String name) { - SpecLevelServer sl = new SpecLevelServer(name, name + " Level"); - try { - assertTrue(sl.write2DB() > 0); - } catch (IllegalOrphanException ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } catch (NonexistentEntityException ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - return sl; - } - - private RequirementSpecServer createRequirementSpec(String name, SpecLevelServer sl) { - RequirementSpecServer rss = new RequirementSpecServer(name, - "description", project.getId(), sl.getId()); - try { - rss.write2DB(); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - return rss; - } -} +package com.validation.manager.core.db; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.controller.RequirementJpaController; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.server.core.ProjectServer; +import com.validation.manager.core.server.core.RequirementServer; +import com.validation.manager.core.server.core.RequirementSpecNodeServer; +import com.validation.manager.core.server.core.RequirementSpecServer; +import com.validation.manager.core.server.core.SpecLevelServer; +import com.validation.manager.test.AbstractVMTestCase; +import com.validation.manager.test.TestHelper; +import static com.validation.manager.test.TestHelper.createRequirement; +import static com.validation.manager.test.TestHelper.createRequirementSpecNode; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; +import static java.util.logging.Logger.getLogger; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RequirementHierarchyTest extends AbstractVMTestCase { + + private static final Logger LOG + = getLogger(RequirementHierarchyTest.class.getName()); + private ProjectServer project; + + @Test + public void testHierarchy() { + System.out.println("Test Requirement Hierarchy"); + System.out.println("Create Project"); + project = new ProjectServer("Test product", "Project Notes"); + try { + project.write2DB(); + } + catch (VMException ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + System.out.println("Create Requirement Spec"); + RequirementSpec rss = null; + try { + rss = TestHelper.createRequirementSpec("Test", "Test", + project, 1); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + System.out.println("Create Requirement Spec Node"); + RequirementSpecNode rsns = null; + try { + rsns = createRequirementSpecNode( + rss, "Test", "Test", "Test"); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + System.out.println("Create Requirements"); + List requirements = new ArrayList<>(); + int requirementAmount = 15; + for (int i = 0; i < requirementAmount; i++) { + try { + Requirement reqs + = createRequirement("SRS-SW-00" + i, + "Description " + i, + rsns.getRequirementSpecNodePK(), + "Notes " + i, 2, 1); + requirements.add(new RequirementJpaController( + getEntityManagerFactory()) + .findRequirement(reqs.getId())); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } + System.out.println("Done!"); + System.out.println("Create Requirement Spec Levels"); + SpecLevelServer userSpecLevel = createSpecLevel("User Requirement"); + SpecLevelServer functionalSpecLevel + = createSpecLevel("Functional Requirement"); + SpecLevelServer unitSpecLevel = createSpecLevel("Unit Requirement"); + System.out.println("Done!"); + System.out.println("Create Requirement Specs"); + RequirementSpecServer productSpec = createRequirementSpec( + "Project Spec", userSpecLevel); + RequirementSpecServer archSpec = createRequirementSpec( + "Architectural Spec", functionalSpecLevel); + RequirementSpecServer swSpec = createRequirementSpec( + "Software Spec", unitSpecLevel); + System.out.println("Done!"); + System.out.println("Adding requirements to spec nodes"); + try { + RequirementSpecNodeServer n1 + = productSpec.addSpecNode("Node 1", "description", "scope"); + requirements.subList(0, 5).forEach((r) -> { + n1.getRequirementList().add(r); + }); + n1.write2DB(); + assertEquals(1, productSpec.getRequirementSpecNodeList().size()); + RequirementSpecNodeServer n2 + = archSpec.addSpecNode("Node 2", "description", "scope"); + requirements.subList(5, 10).forEach((r) -> { + n2.getRequirementList().add(r); + }); + n2.write2DB(); + assertEquals(1, archSpec.getRequirementSpecNodeList().size()); + RequirementSpecNodeServer n3 + = swSpec.addSpecNode("Node 3", "description", "scope"); + requirements.subList(10, 15).forEach((r) -> { + n3.getRequirementList().add(r); + }); + n3.write2DB(); + assertEquals(1, swSpec.getRequirementSpecNodeList().size()); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + System.out.println("Done!"); + System.out.println("Adding requirements to requirements"); + int count = 0; + for (Requirement req : requirements) { + try { + req.getRequirementList().add(requirements.get(requirementAmount - count - 1)); + new RequirementServer(req).write2DB(); + count++; + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } + System.out.println("Done!"); + } + + private SpecLevelServer createSpecLevel(String name) { + SpecLevelServer sl = new SpecLevelServer(name, name + " Level"); + try { + assertTrue(sl.write2DB() > 0); + } + catch (IllegalOrphanException ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + catch (NonexistentEntityException ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + return sl; + } + + private RequirementSpecServer createRequirementSpec(String name, SpecLevelServer sl) { + RequirementSpecServer rss = new RequirementSpecServer(name, + "description", project.getId(), sl.getId()); + try { + rss.write2DB(); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + return rss; + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/db/UserTest.java b/VM-Core/src/test/java/com/validation/manager/core/db/UserTest.java index c90d9e84..f70f626c 100755 --- a/VM-Core/src/test/java/com/validation/manager/core/db/UserTest.java +++ b/VM-Core/src/test/java/com/validation/manager/core/db/UserTest.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,57 +13,56 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.db; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import static com.validation.manager.core.DataBaseManager.namedQuery; -import com.validation.manager.core.db.controller.UserStatusJpaController; -import com.validation.manager.core.db.controller.VmUserJpaController; -import static com.validation.manager.core.tool.MD5.encrypt; -import com.validation.manager.test.AbstractVMTestCase; -import java.util.Date; -import java.util.logging.Level; -import static java.util.logging.Logger.getLogger; -import org.junit.Test; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class UserTest extends AbstractVMTestCase { - - @Test - @SuppressWarnings({"unchecked"}) - public void testCreateAndDeleteUser() { - try { - getLogger(UserTest.class.getSimpleName()).log(Level.INFO, - "Available users: {0}", - new VmUserJpaController(getEntityManagerFactory()) - .getVmUserCount()); - getLogger(UserTest.class.getSimpleName()).log(Level.INFO, - "Create an user"); - VmUser u = new VmUser("test", - encrypt("password"), "test@test.com", - "first", "last", "en", new Date(), - new UserStatusJpaController(getEntityManagerFactory()) - .findUserStatus(1), 0); - u.setUserStatusId(new UserStatusJpaController( - getEntityManagerFactory()).findUserStatus(1)); - new VmUserJpaController(getEntityManagerFactory()).create(u); - parameters.clear(); - parameters.put("username", "test"); - result = namedQuery("VmUser.findByUsername", parameters); - assertTrue(result.size() > 0); - u = (VmUser) result.get(0); - getLogger(UserTest.class.getSimpleName()).log(Level.INFO, - "Delete an user"); - new VmUserJpaController(getEntityManagerFactory()) - .destroy(u.getId()); - result = namedQuery("VmUser.findByUsername", parameters); - assertTrue(result.isEmpty()); - } - catch (Exception e) { - fail(e.getMessage()); - } - } -} +package com.validation.manager.core.db; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import static com.validation.manager.core.DataBaseManager.namedQuery; +import com.validation.manager.core.db.controller.UserStatusJpaController; +import com.validation.manager.core.db.controller.VmUserJpaController; +import static com.validation.manager.core.tool.MD5.encrypt; +import com.validation.manager.test.AbstractVMTestCase; +import java.util.logging.Level; +import static java.util.logging.Logger.getLogger; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class UserTest extends AbstractVMTestCase { + + @Test + @SuppressWarnings({"unchecked"}) + public void testCreateAndDeleteUser() { + try { + getLogger(UserTest.class.getSimpleName()).log(Level.INFO, + "Available users: {0}", + new VmUserJpaController(getEntityManagerFactory()) + .getVmUserCount()); + getLogger(UserTest.class.getSimpleName()).log(Level.INFO, + "Create an user"); + VmUser u = new VmUser("test", + encrypt("password"), "test@test.com", + "first", "last", "en", + new UserStatusJpaController(getEntityManagerFactory()) + .findUserStatus(1), 0); + u.setUserStatusId(new UserStatusJpaController( + getEntityManagerFactory()).findUserStatus(1)); + new VmUserJpaController(getEntityManagerFactory()).create(u); + parameters.clear(); + parameters.put("username", "test"); + result = namedQuery("VmUser.findByUsername", parameters); + assertTrue(result.size() > 0); + u = (VmUser) result.get(0); + getLogger(UserTest.class.getSimpleName()).log(Level.INFO, + "Delete an user"); + new VmUserJpaController(getEntityManagerFactory()) + .destroy(u.getId()); + result = namedQuery("VmUser.findByUsername", parameters); + assertTrue(result.isEmpty()); + } + catch (Exception e) { + fail(e.getMessage()); + } + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/history/VersionableTest.java b/VM-Core/src/test/java/com/validation/manager/core/history/VersionableTest.java new file mode 100644 index 00000000..bd07119c --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/history/VersionableTest.java @@ -0,0 +1,289 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.history; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.DemoBuilder; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.controller.HistoryJpaController; +import com.validation.manager.test.AbstractVMTestCase; +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.EntityManager; +import javax.persistence.metamodel.EntityType; +import static junit.framework.TestCase.assertEquals; +import org.apache.commons.lang3.reflect.FieldUtils; +import org.junit.Test; +import org.openide.util.Exceptions; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class VersionableTest extends AbstractVMTestCase { + + /** + * Test of increaseMajorVersion method, of class Versionable. + */ + @Test + public void testIncreaseMajorVersion() { + System.out.println("increaseMajorVersion"); + Versionable instance = new VersionableImpl(); + assertEquals(0, (int) instance.getMajorVersion()); + assertEquals(0, (int) instance.getMidVersion()); + assertEquals(1, (int) instance.getMinorVersion()); + instance.increaseMajorVersion(); + assertEquals(1, (int) instance.getMajorVersion()); + assertEquals(0, (int) instance.getMidVersion()); + assertEquals(0, (int) instance.getMinorVersion()); + assertEquals(2, instance.getHistoryList().size()); + checkHistory(instance); + } + + /** + * Test of increaseMidVersion method, of class Versionable. + */ + @Test + public void testIncreaseMidVersion() { + System.out.println("increaseMidVersion"); + Versionable instance = new VersionableImpl(); + assertEquals(0, (int) instance.getMajorVersion()); + assertEquals(0, (int) instance.getMidVersion()); + assertEquals(1, (int) instance.getMinorVersion()); + instance.increaseMidVersion(); + assertEquals(0, (int) instance.getMajorVersion()); + assertEquals(1, (int) instance.getMidVersion()); + assertEquals(0, (int) instance.getMinorVersion()); + assertEquals(2, instance.getHistoryList().size()); + checkHistory(instance); + } + + /** + * Test of toString method, of class Versionable. + */ + @Test + public void testToString() { + System.out.println("toString"); + Versionable instance = new VersionableImpl(); + String r = instance.toString(); + assertEquals("Version: " + instance.getMajorVersion() + + "." + instance.getMidVersion() + "." + + instance.getMinorVersion(), instance.toString()); + instance.increaseMajorVersion(); + assertEquals("Version: " + instance.getMajorVersion() + + "." + instance.getMidVersion() + "." + + instance.getMinorVersion(), instance.toString()); + instance.increaseMidVersion(); + assertEquals("Version: " + instance.getMajorVersion() + + "." + instance.getMidVersion() + "." + + instance.getMinorVersion(), instance.toString()); + } + + /** + * Test of compareTo method, of class Versionable. + */ + @Test + public void testCompareTo() { + System.out.println("compareTo"); + Versionable instance = new VersionableImpl(); + assertEquals(0, instance.compareTo(new VersionableImpl())); + instance.increaseMidVersion(); + assertEquals(1, instance.compareTo(new VersionableImpl())); + Versionable instance2 = new VersionableImpl(); + instance2.increaseMajorVersion(); + assertEquals(-1, instance.compareTo(instance2)); + } + + /** + * Test of auditable method, of class Versionable. + */ + @Test + public void testAuditable() { + try { + System.out.println("auditable"); + VersionableImpl v = new VersionableImpl(); + assertEquals(true, Versionable.auditable(v)); + v.updateHistory(); + assertEquals(1, v.getHistoryList().size()); + assertEquals(false, Versionable.auditable(v)); + v.setField1(2); + v.updateHistory(); + assertEquals(1, v.getHistoryList().size()); + assertEquals(false, Versionable.auditable(v)); + v.setField2("new value"); + assertEquals(true, Versionable.auditable(v)); + v.updateHistory(); + assertEquals(2, v.getHistoryList().size()); + } + catch (Exception ex) { + Exceptions.printStackTrace(ex); + fail(); + } + } + + @Test + public void testVersioning() { + try { + DemoBuilder.buildDemoProject(); + EntityManager em = DataBaseManager.getEntityManager(); + //Populate with demo classes. + for (EntityType entity : em.getMetamodel().getEntities()) { + if (Versionable.class.isAssignableFrom(entity.getJavaType())) { + final String className = entity.getName(); + System.out.println("Testing class: " + className); + //Make sure they have at least one auditable field. + List fields = FieldUtils + .getFieldsListWithAnnotation(entity.getJavaType(), + Auditable.class); + assertEquals(false, fields.isEmpty()); + //Get one from the demo data + Versionable v = (Versionable) DataBaseManager.createdQuery("Select a from " + + entity.getJavaType().getSimpleName() + + " a").get(0); + assertNotNull(v); + v.updateHistory(); + int count = v.getHistoryList().size(); + for (Field f : fields) { + //Now pick one of the Auditable fields + assertEquals(count, v.getHistoryList().size()); + History history = v.getHistoryList().get(v + .getHistoryList().size() - 1); + assertEquals(count == 1 ? "audit.general.creation" + : "audit.general.modified", history.getReason()); + assertEquals(0, history.getMajorVersion()); + assertEquals(0, history.getMidVersion()); + assertEquals(count++, history.getMinorVersion()); + assertEquals(1, (int) history.getModifierId().getId()); + assertNotNull(history.getModificationTime()); + assertTrue(checkHistory(v)); + assertFalse(Versionable.auditable(v)); + System.out.println("Changing field: " + + f.getName() + " Type: " + + f.getType().getSimpleName()); + f.setAccessible(true); + if (f.getType() == Integer.class) { + Integer current = (Integer) f.get(v); + Integer newValue = current + 1; + showChange(current, newValue); + f.set(v, newValue); + } else if (f.getType() == String.class) { + String current = (String) f.get(v); + String newValue = current + 1; + showChange(current, newValue); + f.set(v, newValue); + } else if (f.getType() == byte[].class) { + byte[] current = (byte[]) f.get(v); + byte[] append = "1".getBytes(); + byte[] newValue = new byte[current.length + append.length]; + showChange(current, newValue); + f.set(v, newValue); + } else if (f.getType() == Boolean.class) { + Boolean current = (Boolean) f.get(v); + Boolean newValue = !current; + showChange(current, newValue); + f.set(v, newValue); + } else { + fail("Unexpected field type: " + + f.getType().getSimpleName()); + } + assertTrue(Versionable.auditable(v)); + v.updateHistory(); + assertEquals(count, v.getHistoryList().size()); + history = v.getHistoryList().get(v.getHistoryList().size() - 1); + assertEquals(0, history.getMajorVersion()); + assertEquals(0, history.getMidVersion()); + assertEquals(count, history.getMinorVersion()); + assertEquals(1, (int) history.getModifierId().getId()); + assertEquals("audit.general.modified", history.getReason()); + assertNotNull(history.getModificationTime()); + assertTrue(checkHistory(v)); + assertFalse(Versionable.auditable(v)); + int total = new HistoryJpaController(DataBaseManager + .getEntityManagerFactory()).getHistoryCount(); + //Test for issue #25 https://github.com/javydreamercsw/validation-manager/issues/25 + + v = (Versionable) DataBaseManager.getEntityManager().find(entity.getJavaType(), + DataBaseManager.getEntityManagerFactory() + .getPersistenceUnitUtil().getIdentifier(v)); + assertTrue(checkHistory(v)); + assertEquals(total, new HistoryJpaController(DataBaseManager + .getEntityManagerFactory()).getHistoryCount()); + assertEquals(count, v.getHistoryList().size()); + } + } + } + } + catch (Exception ex) { + Exceptions.printStackTrace(ex); + fail(); + } + } + + private void showChange(Object current, Object newValue) { + System.out.println("Changing int value from: " + + current + " to: " + + newValue); + } + + public class VersionableImpl extends Versionable { + + private List history = new ArrayList<>(); + + private int field1; + + @Auditable + private String field2; + + @Override + public List getHistoryList() { + return history; + } + + @Override + public void setHistoryList(List historyList) { + this.history = historyList; + } + + /** + * @return the field1 + */ + public int getField1() { + return field1; + } + + /** + * @param field1 the field1 to set + */ + public void setField1(int field1) { + this.field1 = field1; + } + + /** + * @return the field2 + */ + public String getField2() { + return field2; + } + + /** + * @param field2 the field2 to set + */ + public void setField2(String field2) { + this.field2 = field2; + } + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/AttachmentTypeServerTest.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/AttachmentTypeServerTest.java new file mode 100644 index 00000000..1367279c --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/AttachmentTypeServerTest.java @@ -0,0 +1,52 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.server.core; + +import com.validation.manager.test.AbstractVMTestCase; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class AttachmentTypeServerTest extends AbstractVMTestCase { + + /** + * Test of write2DB method, of class AttachmentTypeServer. + * + * @throws java.lang.Exception + */ + @Test + public void testWrite2DB() throws Exception { + System.out.println("write2DB"); + AttachmentTypeServer instance = new AttachmentTypeServer(1); + instance.setType("Type2"); + instance.setDescription("Desc2"); + instance.write2DB(); + assertEquals("Type2", instance.getEntity().getType()); + assertEquals("Desc2", instance.getEntity().getDescription()); + } + + /** + * Test of getTypeForExtension method, of class AttachmentTypeServer. + */ + @Test + public void testGetTypeForExtension() { + System.out.println("getTypeForExtension"); + assertNotNull(AttachmentTypeServer.getTypeForExtension("txt")); + assertNull(AttachmentTypeServer.getTypeForExtension("dummy")); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/ExecutionResultServerTest.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/ExecutionResultServerTest.java new file mode 100644 index 00000000..ef69233b --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/ExecutionResultServerTest.java @@ -0,0 +1,63 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.db.controller.ExecutionResultJpaController; +import com.validation.manager.test.AbstractVMTestCase; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ExecutionResultServerTest extends AbstractVMTestCase { + + /** + * Test of write2DB method, of class ExecutionResultServer. + * + * @throws java.lang.Exception + */ + @Test + public void testWrite2DB() throws Exception { + System.out.println("write2DB"); + ExecutionResultServer instance = new ExecutionResultServer(1); + instance.setResultName("test"); + instance.write2DB(); + assertEquals("test", instance.getEntity().getResultName()); + } + + /** + * Test of getResult method, of class ExecutionResultServer. + */ + @Test + public void testGetResult() { + System.out.println("getResult"); + assertNotNull(ExecutionResultServer.getResult("result.pass")); + assertNull(ExecutionResultServer.getResult("result.dummy")); + } + + /** + * Test of getResults method, of class ExecutionResultServer. + */ + @Test + public void testGetResults() { + System.out.println("getResults"); + assertEquals(new ExecutionResultJpaController(DataBaseManager + .getEntityManagerFactory()).getExecutionResultCount(), + ExecutionResultServer.getResults().size()); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/IssueTypeServerTest.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/IssueTypeServerTest.java new file mode 100644 index 00000000..653d9733 --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/IssueTypeServerTest.java @@ -0,0 +1,52 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.server.core; + +import com.validation.manager.test.AbstractVMTestCase; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class IssueTypeServerTest extends AbstractVMTestCase { + + /** + * Test of write2DB method, of class IssueTypeServer. + * + * @throws java.lang.Exception + */ + @Test + public void testWrite2DB() throws Exception { + System.out.println("write2DB"); + IssueTypeServer instance = new IssueTypeServer(1); + instance.setTypeName("test"); + instance.setDescription("desc"); + instance.write2DB(); + assertEquals("test", instance.getEntity().getTypeName()); + assertEquals("desc", instance.getEntity().getDescription()); + } + + /** + * Test of getType method, of class IssueTypeServer. + */ + @Test + public void testGetType() { + System.out.println("getType"); + assertNotNull(IssueTypeServer.getType("bug.name")); + assertNull(IssueTypeServer.getType("dummy")); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/NotificationServerTest.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/NotificationServerTest.java index 7c753cb8..72685e34 100644 --- a/VM-Core/src/test/java/com/validation/manager/core/server/core/NotificationServerTest.java +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/NotificationServerTest.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,52 +13,60 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.test.AbstractVMTestCase; -import java.util.Date; -import org.junit.Test; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class NotificationServerTest extends AbstractVMTestCase { - - /** - * Test of write2DB method, of class NotificationServer. - * - * @throws java.lang.Exception - */ - @Test - public void testWrite2DB() throws Exception { - System.out.println("write2DB"); - VMUserServer author = new VMUserServer(1); - VMUserServer target = new VMUserServer(2); - NotificationServer instance = new NotificationServer(); - instance.setAuthor(author.getEntity()); - instance.setContent("Hello there!"); - instance.setCreationDate(new Date()); - instance.setNotificationType(NotificationTypeServer - .getType("notification.test.pending")); - instance.setTargetUser(target.getEntity()); - assertEquals(0, author.getNotificationList().size()); - assertEquals(0, target.getNotificationList().size()); - assertEquals(0, author.getNotificationList1().size()); - assertEquals(0, target.getNotificationList1().size()); - instance.write2DB(); - author.update(); - target.update(); - assertEquals(0, author.getNotificationList().size()); - assertEquals(1, target.getNotificationList().size()); - assertEquals(1, author.getNotificationList1().size()); - assertEquals(0, target.getNotificationList1().size()); - assertEquals(0, author.getPendingNotifications().size()); - assertEquals(1, target.getPendingNotifications().size()); - NotificationServer ns = new NotificationServer(target - .getNotificationList().get(0)); - ns.setAcknowledgeDate(new Date()); - ns.write2DB(); - assertEquals(0, target.getPendingNotifications().size()); - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.test.AbstractVMTestCase; +import java.util.Date; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class NotificationServerTest extends AbstractVMTestCase { + + /** + * Test of write2DB method, of class NotificationServer. + * + * @throws java.lang.Exception + */ + @Test + public void testWrite2DB() throws Exception { + System.out.println("write2DB"); + VMUserServer author = new VMUserServer(1); + VMUserServer target = new VMUserServer(2); + NotificationServer instance = new NotificationServer(); + instance.setAuthor(author.getEntity()); + instance.setContent("Hello there!"); + instance.setCreationDate(new Date()); + instance.setNotificationType(NotificationTypeServer + .getType("notification.test.pending")); + instance.setTargetUser(target.getEntity()); + assertEquals(0, author.getNotificationList().size()); + assertEquals(0, target.getNotificationList().size()); + assertEquals(0, author.getNotificationList1().size()); + assertEquals(0, target.getNotificationList1().size()); + instance.write2DB(); + author.update(); + target.update(); + assertEquals(0, author.getNotificationList().size()); + assertEquals(1, target.getNotificationList().size()); + assertEquals(1, author.getNotificationList1().size()); + assertEquals(0, target.getNotificationList1().size()); + assertEquals(0, author.getPendingNotifications().size()); + assertEquals(1, target.getPendingNotifications().size()); + NotificationServer ns = new NotificationServer(target + .getNotificationList().get(0)); + ns.setAcknowledgeDate(new Date()); + ns.write2DB(); + assertEquals(0, target.getPendingNotifications().size()); + NotificationServer instance2 = new NotificationServer(); + instance2.setAuthor(author.getEntity()); + instance2.setContent("Hello there!"); + instance2.setCreationDate(new Date()); + instance2.setNotificationType(NotificationTypeServer + .getType("notification.test.pending")); + instance2.setTargetUser(target.getEntity()); + instance2.write2DB(); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/ProjectServerTest.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/ProjectServerTest.java index 2acc3e88..dda0d483 100644 --- a/VM-Core/src/test/java/com/validation/manager/core/server/core/ProjectServerTest.java +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/ProjectServerTest.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,159 +13,92 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.VMException; -import com.validation.manager.core.db.Project; -import com.validation.manager.core.db.Requirement; -import com.validation.manager.core.db.RequirementSpec; -import com.validation.manager.core.db.RequirementSpecNode; -import com.validation.manager.core.db.controller.ProjectJpaController; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.tool.Tool; -import com.validation.manager.test.AbstractVMTestCase; -import com.validation.manager.test.TestHelper; -import java.util.logging.Level; -import java.util.logging.Logger; -import static junit.framework.TestCase.assertTrue; -import static junit.framework.TestCase.fail; -import org.junit.Test; -import org.openide.util.Exceptions; -import static org.openide.util.Exceptions.printStackTrace; - -/** - * - * @author jortiz00 - */ -public class ProjectServerTest extends AbstractVMTestCase { - - private Project p; - private static final Logger LOG - = Logger.getLogger(ProjectServerTest.class.getSimpleName()); - - @Override - protected void postSetUp() { - try { - RequirementSpec rss = null; - p = TestHelper.createProject("New Project", "Notes"); - ProjectServer project = new ProjectServer(p); - project.setNotes("Notes 2"); - project.write2DB(); - assertTrue(new ProjectJpaController( - DataBaseManager.getEntityManagerFactory()) - .findProject(project.getId()).getNotes().equals(project.getNotes())); - //Create requirements - System.out.println("Create Requirement Spec"); - try { - rss = TestHelper.createRequirementSpec("Test", "Test", - project, 1); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - System.out.println("Create Requirement Spec Node"); - try { - TestHelper.createRequirementSpecNode( - rss, "Test", "Test", "Test"); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - } - catch (NonexistentEntityException ex) { - Exceptions.printStackTrace(ex); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - } - - /** - * Test of create and deleteProject method, of class ProjectServer. - */ - @Test - public void testCreateAndDeleteProject() { - try { - System.out.println("Create a project"); - Project root = TestHelper.createProject("Test", "Notes"); - System.out.println("Add a sub project"); - Project sub = TestHelper.addProject(root, "Sub", "Notes"); - System.out.println("Create Spec for main project."); - //No errors, nothing dependent - try { - ProjectServer.deleteProject(sub); - } - catch (VMException ex) { - printStackTrace(ex); - fail(); - } - assertTrue(Tool.extractRequirements(root).isEmpty()); - RequirementSpec mainSpec - = TestHelper.createRequirementSpec("Spec", "Desc", root, 1); - assertTrue(!root.getRequirementSpecList().isEmpty()); - assertEquals(0, Tool.extractRequirements(root).size()); - sub = TestHelper.addProject(root, "Sub", "Notes"); - System.out.println("Create Spec for sub project."); - RequirementSpec spec = TestHelper.createRequirementSpec("Spec 2", - "Desc", sub, 1); - RequirementSpecNode node = TestHelper.createRequirementSpecNode(mainSpec, - "Requirement Doc", "Desc", "Scope"); - Requirement req1 = TestHelper.createRequirement("REQ-001", "Desc", - node.getRequirementSpecNodePK(), "Notes", 1, 1); - assertEquals(1, Tool.extractRequirements(root).size()); - Requirement req2 = TestHelper.createRequirement("REQ-002", "Desc", - node.getRequirementSpecNodePK(), "Notes", 1, 1); - assertEquals(2, Tool.extractRequirements(root).size()); - TestHelper.addChildToRequirement(req1, req2); - try { - ProjectServer.deleteProject(sub); - } - catch (VMException ex) { - //Expected failure - System.out.println("Expected failure!"); - } - RequirementSpecServer.deleteRequirementSpec(spec); - try { - ProjectServer.deleteProject(new ProjectServer(sub).getEntity()); - } - catch (VMException ex) { - printStackTrace(ex); - fail(); - } - } - catch (Exception ex) { - printStackTrace(ex); - fail(); - } - } - - @Test - public void testExtractTestProjects() { - try { - System.out.println("Add Test Project"); - TestHelper.addTestProjectToProject(TestHelper - .createTestProject("Test"), p); - for (int i = 0; i < 5; i++) { - Project sub = TestHelper.addProject(p, "Sub #" + i, - "Notes #" + i); - TestHelper.addTestProjectToProject(TestHelper - .createTestProject("Test"), sub); - } - ProjectServer ps = new ProjectServer(p); - assertEquals(1, ps.getTestProjects(false).size()); - assertEquals(1 + ps.getProjectList().size(), - ps.getTestProjects(true).size()); - } - catch (NonexistentEntityException ex) { - Exceptions.printStackTrace(ex); - fail(); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - fail(); - } - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.Project; +import com.validation.manager.core.db.RequirementSpec; +import com.validation.manager.core.db.controller.ProjectJpaController; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.test.AbstractVMTestCase; +import com.validation.manager.test.TestHelper; +import java.util.logging.Level; +import java.util.logging.Logger; +import static junit.framework.TestCase.assertTrue; +import static junit.framework.TestCase.fail; +import org.junit.Test; + +/** + * + * @author jortiz00 + */ +public class ProjectServerTest extends AbstractVMTestCase { + + private Project p; + private static final Logger LOG + = Logger.getLogger(ProjectServerTest.class.getSimpleName()); + + @Override + protected void postSetUp() { + try { + RequirementSpec rss = null; + p = TestHelper.createProject("New Project", "Notes"); + ProjectServer project = new ProjectServer(p); + project.setNotes("Notes 2"); + project.write2DB(); + assertTrue(new ProjectJpaController( + DataBaseManager.getEntityManagerFactory()) + .findProject(project.getId()).getNotes().equals(project.getNotes())); + //Create requirements + System.out.println("Create Requirement Spec"); + try { + rss = TestHelper.createRequirementSpec("Test", "Test", + project, 1); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + System.out.println("Create Requirement Spec Node"); + try { + TestHelper.createRequirementSpecNode( + rss, "Test", "Test", "Test"); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } + catch (VMException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + + @Test + public void testExtractTestProjects() { + try { + System.out.println("Add Test Project"); + TestHelper.addTestProjectToProject(TestHelper + .createTestProject("Test"), p); + for (int i = 0; i < 5; i++) { + Project sub = TestHelper.addProject(p, "Sub #" + i, + "Notes #" + i); + TestHelper.addTestProjectToProject(TestHelper + .createTestProject("Test"), sub); + } + ProjectServer ps = new ProjectServer(p); + assertEquals(1, ps.getTestProjects(false).size()); + assertEquals(1 + ps.getProjectList().size(), + ps.getTestProjects(true).size()); + } + catch (NonexistentEntityException ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/RequirementServerTest.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/RequirementServerTest.java index 38b8e36e..aa5dab43 100644 --- a/VM-Core/src/test/java/com/validation/manager/core/server/core/RequirementServerTest.java +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/RequirementServerTest.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,390 +13,313 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.Project; -import com.validation.manager.core.db.Requirement; -import com.validation.manager.core.db.RequirementSpec; -import com.validation.manager.core.db.RequirementSpecNode; -import com.validation.manager.core.db.Step; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.TestPlan; -import com.validation.manager.core.db.TestProject; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.HistoryJpaController; -import com.validation.manager.core.db.controller.ProjectJpaController; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.test.AbstractVMTestCase; -import com.validation.manager.test.TestHelper; -import java.util.logging.Level; -import java.util.logging.Logger; -import static java.util.logging.Logger.getLogger; -import org.junit.Test; -import org.openide.util.Exceptions; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class RequirementServerTest extends AbstractVMTestCase { - - private static final Logger LOG - = getLogger(RequirementServerTest.class.getName()); - private Project p; - private RequirementSpecNode rsn; - - @Override - protected void postSetUp() { - try { - RequirementSpec rss = null; - p = TestHelper.createProject("New Project", "Notes"); - ProjectServer project = new ProjectServer(p); - project.setNotes("Notes 2"); - project.write2DB(); - assertTrue(new ProjectJpaController( - DataBaseManager.getEntityManagerFactory()) - .findProject(project.getId()).getNotes().equals(project.getNotes())); - //Create requirements - System.out.println("Create Requirement Spec"); - try { - rss = TestHelper.createRequirementSpec("Test", "Test", - project, 1); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - System.out.println("Create Requirement Spec Node"); - try { - rsn = TestHelper.createRequirementSpecNode( - rss, "Test", "Test", "Test"); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - } - catch (NonexistentEntityException ex) { - Exceptions.printStackTrace(ex); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - } - - /** - * Test of update method, of class RequirementServer. - */ - @Test - public void testUpdate() { - try { - System.out.println("update"); - Requirement source = TestHelper.createRequirement("SRS-SW-0001", - "Sample requirement", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - RequirementServer instance = new RequirementServer(source); - assertEquals(1, instance.getHistoryList().size()); - int count = 1; - for (History h : instance.getHistoryList()) { - assertEquals(0, h.getMajorVersion()); - assertEquals(0, h.getMidVersion()); - assertEquals(count, h.getMinorVersion()); - count++; - } - Requirement target = new Requirement(); - instance.update(target, source); - assertEquals(instance.getUniqueId(), target.getUniqueId()); - assertEquals(instance.getDescription(), target.getDescription()); - assertEquals(instance.getNotes(), target.getNotes()); - assertEquals(instance.getRequirementTypeId().getId(), - target.getRequirementTypeId().getId()); - assertEquals(instance.getRequirementStatusId().getId(), - target.getRequirementStatusId().getId()); - assertEquals(instance.getHistoryList().size(), - target.getHistoryList().size()); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - } - - /** - * Test of isDuplicate method, of class RequirementServer. - */ - @Test - public void testIsDuplicate() { - try { - System.out.println("isDuplicate"); - Requirement source = TestHelper.createRequirement("SRS-SW-0001", - "Sample requirement", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - Requirement source2 = TestHelper.createRequirement("SRS-SW-0002", - "Sample requirement", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - assertEquals(false, RequirementServer.isDuplicate(source)); - assertEquals(false, RequirementServer.isDuplicate(source2)); - Requirement source3 = TestHelper.createRequirement("SRS-SW-0002", - "Sample requirement", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - assertEquals(true, RequirementServer.isDuplicate(source3)); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - } - - /** - * Test of getTestCoverage method, of class RequirementServer. - */ - @Test - public void testGetTestCoverage() { - try { - System.out.println("getTestCoverage"); - Requirement req = TestHelper.createRequirement("SRS-SW-0001", - "Sample requirement", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - Requirement req2 = TestHelper.createRequirement("SRS-SW-0002", - "Sample requirement", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - Requirement req3 = TestHelper.createRequirement("SRS-SW-0003", - "Sample requirement", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - Requirement req4 = TestHelper.createRequirement("SRS-SW-0004", - "Sample requirement", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - Requirement userReq = TestHelper.createRequirement("PS-SW-0001", - "Sample User requirement", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - RequirementServer rs = new RequirementServer(req); - assertEquals(0, rs.getTestCoverage()); - //Create Test Case - TestCase tc = TestHelper.createTestCase("Dummy", "Summary"); - //Add steps - int i = 1; - for (; i < 6; i++) { - LOG.log(Level.INFO, "Adding step: {0}", i); - tc = TestHelper.addStep(tc, i, "Step " + i, "Note " + i, "Result " + i); - Step step = tc.getStepList().get(i - 1); - TestHelper.addRequirementToStep(step, req); - new TestCaseServer(tc).write2DB(); - assertEquals(1, new StepServer(step).getRequirementList().size()); - } - LOG.log(Level.INFO, "Adding step: {0}", i); - tc = TestHelper.addStep(tc, i, "Step " + i, "Note " + i, "Result " + i); - Step step = tc.getStepList().get(i - 1); - TestHelper.addRequirementToStep(step, req3); - new TestCaseServer(tc).write2DB(); - //Create test Project - TestProject tp = TestHelper.createTestProject("Test Project"); - //Create test plan - TestPlan plan = TestHelper.createTestPlan(tp, "Notes", true, true); - //Add test to plan - TestHelper.addTestCaseToPlan(plan, tc); - rs.update(); - assertEquals(100, rs.getTestCoverage()); - //Add a related requirement - rs.addChildRequirement(req3); - assertEquals(100, rs.getTestCoverage()); - rs.addChildRequirement(req2); - assertEquals(50, rs.getTestCoverage()); - rs.addChildRequirement(req4); - assertEquals(33, rs.getTestCoverage()); - //Add related requirements to test coverage - RequirementServer ur = new RequirementServer(userReq); - assertEquals(0, ur.getTestCoverage()); - ur.addChildRequirement(req); - assertEquals(33, ur.getTestCoverage()); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - } - - /** - * Test of getChildrenRequirement method, of class RequirementServer. - */ - @Test - public void testChildAndParentRequirements() { - try { - System.out.println("Child And Parent Requirements"); - Requirement req = TestHelper.createRequirement("SRS-SW-0001", - "Sample requirement", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - Requirement req2 = TestHelper.createRequirement("SRS-SW-0002", - "Sample requirement", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - assertTrue(req.getRequirementList().isEmpty()); - //Add a child - RequirementServer rs = new RequirementServer(req); - //Add a version to the requirement - DataBaseManager.setVersioningEnabled(true); - rs.setDescription("Modified requirement"); - rs.write2DB(); - rs.addChildRequirement(req2); - RequirementServer rs2 = new RequirementServer(req2); - //Should have one children now - assertEquals(1, rs.getEntity().getRequirementList().size()); - //No parents - assertNull(rs.getEntity().getParentRequirementId()); - //One parent - assertNotNull(rs2.getEntity().getParentRequirementId()); - //No children - assertEquals(0, rs2.getEntity().getRequirementList().size()); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - } - - /** - * Test of requirement coverage with versioning method, of class - * RequirementServer. - */ - @Test - public void testRequirementCoverage() { - try { - System.out.println("Requirement Coverage and Versioning"); - //Enable versioning - DataBaseManager.setVersioningEnabled(true); - Requirement req = TestHelper.createRequirement("SRS-SW-0001", - "Description", rsn.getRequirementSpecNodePK(), "Notes", 1, 1); - RequirementServer rs = new RequirementServer(req); - //Add a test case covering this test case - TestProject tp = TestHelper.createTestProject("Test Project"); - TestHelper.addTestProjectToProject(tp, p); - TestPlan plan = TestHelper.createTestPlan(tp, "Plan", true, true); - TestCase tc = TestHelper.createTestCase("TC #1", - "Summary"); - TestHelper.addTestCaseToPlan(plan, tc); - TestCase step = TestHelper.addStep(tc, 1, "Test", "Test", "Result "); - rs.getStepList().add(step.getStepList().get(0)); - rs.write2DB(); - assertEquals(1, rs.getStepList().size()); - assertEquals(100, rs.getTestCoverage()); - //Update version and remove test coverage - rs.setDescription("New version"); - rs.getStepList().clear(); - rs.write2DB(); - assertEquals(0, rs.getStepList().size()); - rs.update(); - assertEquals(0, rs.getTestCoverage()); - rs.setDescription("New version 2"); - StepServer ss = new StepServer(step.getStepList().get(0)); - ss.removeRequirement(req); - ss.write2DB(); - ss.addRequirement(rs.getEntity()); - rs.update(); - rs.write2DB(); - assertEquals(1, rs.getStepList().size()); - assertEquals(100, rs.getTestCoverage()); - //Add a parent requirement - Requirement r = TestHelper.createRequirement("PS-0001", - "Description", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - RequirementServer parent = new RequirementServer(r); - parent.addChildRequirement(req); - parent.write2DB(); - assertEquals(100, parent.getTestCoverage()); - assertEquals(100, rs.getTestCoverage()); - //Version parent - parent.setDescription("Version 2"); - parent.write2DB(); - assertEquals(100, parent.getTestCoverage()); - assertEquals(100, rs.getTestCoverage()); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - fail(); - } - } - - @Test - public void testVersioning() { - try { - Requirement req = TestHelper.createRequirement("SRS-SW-0001", - "Description", rsn.getRequirementSpecNodePK(), - "Notes", 1, 1); - RequirementServer rs = new RequirementServer(req); - int historyCount = 1; - assertEquals(historyCount++, rs.getHistoryList().size()); - History history = rs.getHistoryList().get(rs - .getHistoryList().size() - 1); - assertEquals(0, history.getMajorVersion()); - assertEquals(0, history.getMidVersion()); - assertEquals(1, history.getMinorVersion()); - assertEquals(1, (int) history.getModifierId().getId()); - assertEquals("audit.general.creation", history.getReason()); - assertNotNull(history.getModificationTime()); - assertTrue(checkHistory(rs)); - rs.setDescription("desc 2"); - rs.write2DB(); - assertEquals(historyCount++, rs.getHistoryList().size()); - history = rs.getHistoryList().get(rs.getHistoryList().size() - 1); - assertEquals(0, history.getMajorVersion()); - assertEquals(0, history.getMidVersion()); - assertEquals(2, history.getMinorVersion()); - assertEquals(1, (int) history.getModifierId().getId()); - assertEquals("audit.general.modified", history.getReason()); - assertNotNull(history.getModificationTime()); - assertTrue(checkHistory(rs)); - rs.setDescription("desc 3"); - VmUser test = TestHelper.createUser("Test", "pass", "email", - "first", "last"); - rs.setModifierId(test.getId()); - rs.setReason("Test"); - rs.write2DB(); - assertEquals(historyCount++, rs.getHistoryList().size()); - history = rs.getHistoryList().get(rs.getHistoryList().size() - 1); - assertEquals(0, history.getMajorVersion()); - assertEquals(0, history.getMidVersion()); - assertEquals(3, history.getMinorVersion()); - assertEquals((int) test.getId(), (int) history.getModifierId().getId()); - assertEquals("Test", history.getReason()); - assertNotNull(history.getModificationTime()); - assertTrue(checkHistory(rs)); - rs.increaseMidVersion(); - assertEquals(historyCount++, rs.getHistoryList().size()); - history = rs.getHistoryList().get(rs.getHistoryList().size() - 1); - assertEquals(0, history.getMajorVersion()); - assertEquals(1, history.getMidVersion()); - assertEquals(0, history.getMinorVersion()); - //TODO: Handle mid and major changes on system - //assertEquals(1, (int) history.getModifierId().getId()); - //assertEquals("tbd", history.getReason()); - assertNotNull(history.getModificationTime()); - assertTrue(checkHistory(rs)); - rs.increaseMajorVersion(); - assertEquals(historyCount, rs.getHistoryList().size()); - history = rs.getHistoryList().get(rs.getHistoryList().size() - 1); - assertEquals(1, history.getMajorVersion()); - assertEquals(0, history.getMidVersion()); - assertEquals(0, history.getMinorVersion()); - //TODO: Handle mid and major changes on system - //assertEquals(1, (int) history.getModifierId().getId()); - //assertEquals("tbd", history.getReason()); - assertNotNull(history.getModificationTime()); - assertTrue(checkHistory(rs)); - int total = new HistoryJpaController(DataBaseManager - .getEntityManagerFactory()).getHistoryCount(); - //Test for issue #25 - //Disconnet to the database - DataBaseManager.close(); - //Reconnect - rs.update(); - assertEquals(total, new HistoryJpaController(DataBaseManager - .getEntityManagerFactory()).getHistoryCount()); - assertEquals(historyCount, rs.getHistoryList().size()); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - fail(); - } - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.Project; +import com.validation.manager.core.db.Requirement; +import com.validation.manager.core.db.RequirementSpec; +import com.validation.manager.core.db.RequirementSpecNode; +import com.validation.manager.core.db.Step; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.TestPlan; +import com.validation.manager.core.db.TestProject; +import com.validation.manager.core.db.controller.ProjectJpaController; +import com.validation.manager.test.AbstractVMTestCase; +import com.validation.manager.test.TestHelper; +import java.util.logging.Level; +import java.util.logging.Logger; +import static java.util.logging.Logger.getLogger; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RequirementServerTest extends AbstractVMTestCase { + + private static final Logger LOG + = getLogger(RequirementServerTest.class.getName()); + private Project p; + private RequirementSpecNode rsn; + private RequirementSpec rss; + + @Override + protected void postSetUp() { + try { + p = TestHelper.createProject("New Project", "Notes"); + ProjectServer project = new ProjectServer(p); + project.setNotes("Notes 2"); + project.write2DB(); + assertTrue(new ProjectJpaController( + DataBaseManager.getEntityManagerFactory()) + .findProject(project.getId()).getNotes().equals(project.getNotes())); + //Create requirements + System.out.println("Create Requirement Spec"); + try { + rss = TestHelper.createRequirementSpec("Test", "Test", + project, 1); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + System.out.println("Create Requirement Spec Node"); + try { + rsn = TestHelper.createRequirementSpecNode( + rss, "Test", "Test", "Test"); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } + catch (VMException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + + /** + * Test of update method, of class RequirementServer. + */ + @Test + public void testUpdate() { + try { + System.out.println("update"); + Requirement source = TestHelper.createRequirement("SRS-SW-0001", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + RequirementServer instance = new RequirementServer(source); + assertEquals(1, instance.getHistoryList().size()); + int count = 1; + for (History h : instance.getHistoryList()) { + assertEquals(0, h.getMajorVersion()); + assertEquals(0, h.getMidVersion()); + assertEquals(count, h.getMinorVersion()); + count++; + } + Requirement target = new Requirement(); + instance.update(target, source); + assertEquals(instance.getUniqueId(), target.getUniqueId()); + assertEquals(instance.getDescription(), target.getDescription()); + assertEquals(instance.getNotes(), target.getNotes()); + assertEquals(instance.getRequirementTypeId().getId(), + target.getRequirementTypeId().getId()); + assertEquals(instance.getRequirementStatusId().getId(), + target.getRequirementStatusId().getId()); + assertEquals(instance.getHistoryList().size(), + target.getHistoryList().size()); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } + + /** + * Test of isDuplicate method, of class RequirementServer. + */ + @Test + public void testIsDuplicate() { + try { + System.out.println("isDuplicate"); + Requirement source = TestHelper.createRequirement("SRS-SW-0001", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + Requirement source2 = TestHelper.createRequirement("SRS-SW-0002", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + assertEquals(false, RequirementServer.isDuplicate(source)); + assertEquals(false, RequirementServer.isDuplicate(source2)); + Requirement source3 = TestHelper.createRequirement("SRS-SW-0002", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + assertEquals(true, RequirementServer.isDuplicate(source3)); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } + + /** + * Test of getTestCoverage method, of class RequirementServer. + */ + @Test + public void testGetTestCoverage() { + try { + System.out.println("getTestCoverage"); + Requirement req = TestHelper.createRequirement("SRS-SW-0001", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + Requirement req2 = TestHelper.createRequirement("SRS-SW-0002", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + Requirement req3 = TestHelper.createRequirement("SRS-SW-0003", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + Requirement req4 = TestHelper.createRequirement("SRS-SW-0004", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + Requirement userReq = TestHelper.createRequirement("PS-SW-0001", + "Sample User requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + RequirementServer rs = new RequirementServer(req); + assertEquals(0, rs.getTestCoverage()); + //Create Test Case + TestCase tc = TestHelper.createTestCase("Dummy", "Summary"); + //Add steps + int i = 1; + for (; i < 6; i++) { + LOG.log(Level.INFO, "Adding step: {0}", i); + tc = TestHelper.addStep(tc, i, "Step " + i, "Note " + i, "Result " + i); + Step step = tc.getStepList().get(i - 1); + TestHelper.addRequirementToStep(step, req); + new TestCaseServer(tc).write2DB(); + assertEquals(1, new StepServer(step).getRequirementList().size()); + } + LOG.log(Level.INFO, "Adding step: {0}", i); + tc = TestHelper.addStep(tc, i, "Step " + i, "Note " + i, "Result " + i); + Step step = tc.getStepList().get(i - 1); + TestHelper.addRequirementToStep(step, req3); + new TestCaseServer(tc).write2DB(); + //Create test Project + TestProject tp = TestHelper.createTestProject("Test Project"); + //Create test plan + TestPlan plan = TestHelper.createTestPlan(tp, "Notes", true, true); + //Add test to plan + TestHelper.addTestCaseToPlan(plan, tc); + rs.update(); + assertEquals(100, rs.getTestCoverage()); + //Add a related requirement + rs.addChildRequirement(req3); + assertEquals(100, rs.getTestCoverage()); + rs.addChildRequirement(req2); + assertEquals(50, rs.getTestCoverage()); + rs.addChildRequirement(req4); + assertEquals(33, rs.getTestCoverage()); + //Add related requirements to test coverage + RequirementServer ur = new RequirementServer(userReq); + assertEquals(0, ur.getTestCoverage()); + ur.addChildRequirement(req); + assertEquals(33, ur.getTestCoverage()); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } + + /** + * Test of getChildrenRequirement method, of class RequirementServer. + */ + @Test + public void testChildAndParentRequirements() { + try { + System.out.println("Child And Parent Requirements"); + Requirement req = TestHelper.createRequirement("SRS-SW-0001", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + Requirement req2 = TestHelper.createRequirement("SRS-SW-0002", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + assertTrue(req.getRequirementList().isEmpty()); + //Add a child + RequirementServer rs = new RequirementServer(req); + //Add a version to the requirement + DataBaseManager.setVersioningEnabled(true); + rs.setDescription("Modified requirement"); + rs.write2DB(); + rs.addChildRequirement(req2); + RequirementServer rs2 = new RequirementServer(req2); + //Should have one children now + assertEquals(1, rs.getEntity().getRequirementList().size()); + //No parents + assertNull(rs.getEntity().getParentRequirementId()); + //One parent + assertNotNull(rs2.getEntity().getParentRequirementId()); + //No children + assertEquals(0, rs2.getEntity().getRequirementList().size()); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } + + @Test + public void testGetRequirements() throws Exception { + assertEquals(0, RequirementSpecServer.getRequirements(rss).size()); + TestHelper.createRequirement("SRS-SW-0001", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + TestHelper.createRequirement("SRS-SW-0002", + "Sample requirement", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + assertEquals(2, RequirementSpecServer.getRequirements(rss).size()); + } + + /** + * Test of requirement coverage with versioning method, of class + * RequirementServer. + */ + @Test + public void testRequirementCoverage() { + try { + System.out.println("Requirement Coverage and Versioning"); + //Enable versioning + DataBaseManager.setVersioningEnabled(true); + Requirement req = TestHelper.createRequirement("SRS-SW-0001", + "Description", rsn.getRequirementSpecNodePK(), "Notes", 1, 1); + RequirementServer rs = new RequirementServer(req); + //Add a test case covering this test case + TestProject tp = TestHelper.createTestProject("Test Project"); + TestHelper.addTestProjectToProject(tp, p); + TestPlan plan = TestHelper.createTestPlan(tp, "Plan", true, true); + TestCase tc = TestHelper.createTestCase("TC #1", + "Summary"); + TestHelper.addTestCaseToPlan(plan, tc); + TestCase step = TestHelper.addStep(tc, 1, "Test", "Test", "Result "); + rs.getStepList().add(step.getStepList().get(0)); + rs.write2DB(); + assertEquals(1, rs.getStepList().size()); + assertEquals(100, rs.getTestCoverage()); + //Update version and remove test coverage + rs.setDescription("New version"); + rs.getStepList().clear(); + rs.write2DB(); + assertEquals(0, rs.getStepList().size()); + rs.update(); + assertEquals(0, rs.getTestCoverage()); + rs.setDescription("New version 2"); + StepServer ss = new StepServer(step.getStepList().get(0)); + ss.removeRequirement(req); + ss.write2DB(); + ss.addRequirement(rs.getEntity()); + rs.update(); + rs.write2DB(); + assertEquals(1, rs.getStepList().size()); + assertEquals(100, rs.getTestCoverage()); + //Add a parent requirement + Requirement r = TestHelper.createRequirement("PS-0001", + "Description", rsn.getRequirementSpecNodePK(), + "Notes", 1, 1); + RequirementServer parent = new RequirementServer(r); + parent.addChildRequirement(req); + parent.write2DB(); + assertEquals(100, parent.getTestCoverage()); + assertEquals(100, rs.getTestCoverage()); + //Version parent + parent.setDescription("Version 2"); + parent.write2DB(); + assertEquals(100, parent.getTestCoverage()); + assertEquals(100, rs.getTestCoverage()); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } +} diff --git a/VM-Core/src/main/java/com/validation/manager/core/tool/Timer.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/RequirementStatusServerTest.java similarity index 50% rename from VM-Core/src/main/java/com/validation/manager/core/tool/Timer.java rename to VM-Core/src/test/java/com/validation/manager/core/server/core/RequirementStatusServerTest.java index d55690d1..30692cef 100644 --- a/VM-Core/src/main/java/com/validation/manager/core/tool/Timer.java +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/RequirementStatusServerTest.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,34 +13,28 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.tool; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class Timer { - - private long start, end; - - public Timer() { - reset(); - } - - public void stop() { - end = System.nanoTime(); - } - - public final void reset() { - start = System.nanoTime(); - } - - public String elapsedTime() { - long timeelapsed = (end - start); - long milliseconds = timeelapsed / 1000; - long seconds = (timeelapsed / 1000) % 60; - long minutes = (timeelapsed / 60000) % 60; - return " (" + minutes + ":" + seconds - + ":" + milliseconds + ")"; - } -} +package com.validation.manager.core.server.core; + +import com.validation.manager.test.AbstractVMTestCase; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RequirementStatusServerTest extends AbstractVMTestCase { + + /** + * Test of write2DB method, of class RequirementStatusServer. + * + * @throws java.lang.Exception + */ + @Test + public void testWrite2DB() throws Exception { + System.out.println("write2DB"); + RequirementStatusServer instance = new RequirementStatusServer("test"); + instance.write2DB(); + assertEquals(instance.getStatus(), instance.getEntity().getStatus()); + assertTrue(instance.getId() > 0); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/RequirementTypeServerTest.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/RequirementTypeServerTest.java new file mode 100644 index 00000000..3e43cdbf --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/RequirementTypeServerTest.java @@ -0,0 +1,52 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.db.controller.RequirementTypeJpaController; +import com.validation.manager.test.AbstractVMTestCase; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RequirementTypeServerTest extends AbstractVMTestCase { + + /** + * Test of write2DB method, of class RequirementTypeServer. + * + * @throws java.lang.Exception + */ + @Test + public void testWrite2DB() throws Exception { + System.out.println("write2DB"); + RequirementTypeServer instance = new RequirementTypeServer("test"); + instance.write2DB(); + assertEquals(instance.getName(), instance.getEntity().getName()); + } + + /** + * Test of getRequirementTypes method, of class RequirementTypeServer. + */ + @Test + public void testGetRequirementTypes() { + System.out.println("getRequirementTypes"); + assertEquals(new RequirementTypeJpaController(DataBaseManager + .getEntityManagerFactory()).getRequirementTypeCount(), + RequirementTypeServer.getRequirementTypes().size()); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/ReviewResultServerTest.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/ReviewResultServerTest.java new file mode 100644 index 00000000..6952a830 --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/ReviewResultServerTest.java @@ -0,0 +1,51 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.server.core; + +import com.validation.manager.test.AbstractVMTestCase; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ReviewResultServerTest extends AbstractVMTestCase { + + /** + * Test of getReview method, of class ReviewResultServer. + */ + @Test + public void testGetReview() { + System.out.println("getReview"); + assertNotNull(ReviewResultServer.getReview("result.pass")); + assertNull(ReviewResultServer.getReview("result.dummy")); + } + + /** + * Test of write2DB method, of class ReviewResultServer. + * + * @throws java.lang.Exception + */ + @Test + public void testWrite2DB() throws Exception { + System.out.println("write2DB"); + ReviewResultServer instance = new ReviewResultServer(1); + instance.setReviewName("test"); + instance.write2DB(); + assertEquals(instance.getReviewName(), + instance.getEntity().getReviewName()); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/RoleServerTest.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/RoleServerTest.java new file mode 100644 index 00000000..d7612dd3 --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/RoleServerTest.java @@ -0,0 +1,50 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.server.core; + +import com.validation.manager.test.AbstractVMTestCase; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class RoleServerTest extends AbstractVMTestCase { + + /** + * Test of getRole method, of class RoleServer. + */ + @Test + public void testGetRole() { + System.out.println("getRole"); + assertNotNull(RoleServer.getRole("admin")); + assertNull(RoleServer.getRole("dummy")); + } + + /** + * Test of write2DB method, of class RoleServer. + * + * @throws java.lang.Exception + */ + @Test + public void testWrite2DB() throws Exception { + System.out.println("write2DB"); + RoleServer instance = new RoleServer(1); + instance.setRoleName("test"); + instance.write2DB(); + assertEquals(instance.getRoleName(), instance.getEntity().getRoleName()); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/UserTestProjectRoleServerTest.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/UserTestProjectRoleServerTest.java new file mode 100644 index 00000000..c0be1f2e --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/UserTestProjectRoleServerTest.java @@ -0,0 +1,69 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.server.core; + +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.db.TestProject; +import com.validation.manager.core.db.controller.UserTestProjectRoleJpaController; +import com.validation.manager.test.AbstractVMTestCase; +import com.validation.manager.test.TestHelper; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class UserTestProjectRoleServerTest extends AbstractVMTestCase { + + /** + * Test of write2DB method, of class UserTestProjectRoleServer. + * + * @throws java.lang.Exception + */ + @Test + public void testWrite2DB() throws Exception { + System.out.println("write2DB"); + createTestUsers(); + TestProject tp = TestHelper.createTestProject("Test"); + UserTestProjectRoleServer instance + = new UserTestProjectRoleServer(tp.getId(), leader.getId(), 1); + instance.write2DB(); + assertEquals(instance.getEntity().getVmUser().getId(), leader.getId()); + assertEquals(instance.getEntity().getTestProject().getId(), tp.getId()); + } + + /** + * Test of deleteUserTestProjectRole method, of class + * UserTestProjectRoleServer. + * + * @throws java.lang.Exception + */ + @Test + public void testDelete() throws Exception { + System.out.println("write2DB"); + createTestUsers(); + TestProject tp = TestHelper.createTestProject("Test"); + UserTestProjectRoleServer instance + = new UserTestProjectRoleServer(tp.getId(), leader.getId(), 1); + instance.write2DB(); + assertEquals(instance.getEntity().getVmUser().getId(), leader.getId()); + assertEquals(instance.getEntity().getTestProject().getId(), tp.getId()); + UserTestProjectRoleServer.deleteUserTestProjectRole(instance.getEntity()); + assertNull(new UserTestProjectRoleJpaController(DataBaseManager + .getEntityManagerFactory()) + .findUserTestProjectRole(instance.getUserTestProjectRolePK())); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/VMUserServerTest.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/VMUserServerTest.java new file mode 100644 index 00000000..7ea84d9b --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/server/core/VMUserServerTest.java @@ -0,0 +1,264 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.server.core; + +import com.validation.manager.core.VMException; +import com.validation.manager.core.tool.MD5; +import com.validation.manager.test.AbstractVMTestCase; +import java.util.Date; +import org.junit.Test; +import org.openide.util.Exceptions; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class VMUserServerTest extends AbstractVMTestCase { + + /** + * Test of write2DB method, of class VMUserServer. + * + * @throws java.lang.Exception + */ + @Test + public void testWrite2DB() throws Exception { + System.out.println("write2DB"); + String user = "test"; + String pw = "test"; + String name = "Test"; + String lastname = "User"; + String email = "test.user@test.com"; + VMUserServer instance = new VMUserServer(user, pw, name, lastname, email); + instance.write2DB(); + assertTrue(instance.getId() > 0); + assertEquals(instance.getId(), instance.getEntity().getId()); + assertEquals(user, instance.getEntity().getUsername()); + assertEquals(MD5.encrypt(pw), instance.getEntity().getPassword()); + assertEquals(name, instance.getEntity().getFirstName()); + assertEquals(lastname, instance.getEntity().getLastName()); + assertEquals(email, instance.getEntity().getEmail()); + assertEquals(1, instance.getHistoryList().size()); + assertEquals(1, instance.getEntity().getHistoryList().size()); + email = "test2@test.com"; + instance.setEmail(email); + instance.write2DB(); + int modifiedAmount = instance.getHistoryModificationList().size(); + assertEquals(instance.getId(), instance.getEntity().getId()); + assertEquals(user, instance.getEntity().getUsername()); + assertEquals(MD5.encrypt(pw), instance.getEntity().getPassword()); + assertEquals(name, instance.getEntity().getFirstName()); + assertEquals(lastname, instance.getEntity().getLastName()); + assertEquals(email, instance.getEntity().getEmail()); + assertEquals(2, instance.getHistoryList().size()); + assertEquals(2, instance.getEntity().getHistoryList().size()); + VMUserServer instance2 = new VMUserServer(user + 2, pw + 2, name + 2, + lastname + 2, email + 2); + instance2.write2DB(); + assertEquals(instance2.getId(), instance2.getEntity().getId()); + assertEquals(user + 2, instance2.getEntity().getUsername()); + assertEquals(MD5.encrypt(pw + 2), instance2.getEntity().getPassword()); + assertEquals(name + 2, instance2.getEntity().getFirstName()); + assertEquals(lastname + 2, instance2.getEntity().getLastName()); + assertEquals(email + 2, instance2.getEntity().getEmail()); + assertEquals(1, instance2.getHistoryList().size()); + assertEquals(1, instance2.getEntity().getHistoryList().size()); + instance2.setEmail(email + 3); + instance2.setModifierId(instance.getId()); + instance2.write2DB(); + assertEquals(instance2.getId(), instance2.getEntity().getId()); + assertEquals(user + 2, instance2.getEntity().getUsername()); + assertEquals(MD5.encrypt(pw + 2), instance2.getEntity().getPassword()); + assertEquals(name + 2, instance2.getEntity().getFirstName()); + assertEquals(lastname + 2, instance2.getEntity().getLastName()); + assertEquals(email + 3, instance2.getEntity().getEmail()); + assertEquals(2, instance2.getHistoryList().size()); + assertEquals(2, instance2.getEntity().getHistoryList().size()); + instance.update(); + assertEquals(modifiedAmount + 1, + instance.getHistoryModificationList().size()); + } + + /** + * Test of getVMUsers method, of class VMUserServer. + */ + @Test + public void testGetVMUsers() { + System.out.println("getVMUsers"); + assertTrue(!VMUserServer.getVMUsers().isEmpty()); + } + + /** + * Test of isPasswordUsable method, of class VMUserServer. + * + * @throws java.lang.Exception + */ + @Test + public void testIsPasswordUsable_String_boolean() throws Exception { + System.out.println("isPasswordUsable"); + String newPass = "test2"; + String user = "test"; + String pw = "test"; + String name = "Test"; + String lastname = "User"; + String email = "test.user@test.com"; + VMUserServer instance = new VMUserServer(user, pw, name, + lastname, email); + instance.write2DB(); + assertEquals(false, instance.isPasswordUsable(pw)); + assertEquals(true, instance.isPasswordUsable(newPass)); + } + + /** + * Test of validCredentials method, of class VMUserServer. + * + */ + @Test + public void testValidCredentials() { + System.out.println("validCredentials"); + String user = "test"; + String pw = "test"; + String name = "Test"; + String lastname = "User"; + String email = "test.user@test.com"; + VMUserServer instance; + try { + instance = new VMUserServer(user, pw, name, + lastname, email); + instance.write2DB(); + assertEquals(1, (int) instance.getEntity().getUserStatusId().getId()); + assertEquals(true, VMUserServer.validCredentials(user, pw, true)); + assertEquals(false, VMUserServer.validCredentials(user, pw + 1, true)); + assertEquals(false, VMUserServer.validCredentials(user + 1, pw + 1, + true)); + assertEquals(false, VMUserServer.validCredentials(user + 1, pw, true)); + assertEquals(true, VMUserServer.validCredentials(user, MD5.encrypt(pw), + false)); + assertEquals(false, VMUserServer.validCredentials(user, + MD5.encrypt(pw) + 1, false)); + try { + assertNotNull(new VMUserServer(user, pw)); + } + catch (VMException ex) { + Exceptions.printStackTrace(ex); + fail(); + } + int attempts = 0; + try { + assertEquals(attempts, instance.getAttempts()); + new VMUserServer(user, pw + 1); + instance.update(); + assertEquals(++attempts, instance.getEntity().getAttempts()); + } + catch (VMException ex) { + Exceptions.printStackTrace(ex); + fail(); + } + try { + new VMUserServer(user + 1, pw + 1); + //Wrong user name so can't be linked with account + instance.update(); + assertEquals(attempts, instance.getEntity().getAttempts()); + } + catch (VMException ex) { + Exceptions.printStackTrace(ex); + fail(); + } + try { + new VMUserServer(user + 1, pw); + //Wrong user name so can't be linked with account + instance.update(); + assertEquals(attempts, instance.getEntity().getAttempts()); + } + catch (VMException ex) { + Exceptions.printStackTrace(ex); + fail(); + } + //Lock the account + try { + for (int i = attempts; i < VMSettingServer + .getSetting("password.attempts").getIntVal(); i++) { + System.out.println("Attempts: " + attempts); + new VMUserServer(user, pw + 1); + instance.update(); + assertEquals(++attempts, instance.getEntity().getAttempts()); + assertEquals(1, (int) instance.getEntity().getUserStatusId().getId()); + } + new VMUserServer(user, pw + 1); + instance.update(); + assertEquals(++attempts, instance.getEntity().getAttempts()); + assertEquals(4, (int) instance.getEntity().getUserStatusId().getId()); + } + catch (VMException ex) { + Exceptions.printStackTrace(ex); + fail(); + } + } + catch (Exception ex) { + Exceptions.printStackTrace(ex); + fail(); + } + } + + /** + * Test of getPendingNotifications method, of class VMUserServer. + * + * @throws java.lang.Exception + */ + @Test + public void testGetPendingNotifications() throws Exception { + System.out.println("getPendingNotifications"); + String user = "test"; + String pw = "test"; + String name = "Test"; + String lastname = "User"; + String email = "test.user@test.com"; + VMUserServer instance = new VMUserServer(user, pw, name, + lastname, email); + instance.write2DB(); + assertEquals(0, instance.getPendingNotifications().size()); + NotificationServer ns = new NotificationServer(); + ns.setAuthor(new VMUserServer(1).getEntity()); + ns.setContent("Hello there!"); + ns.setCreationDate(new Date()); + ns.setNotificationType(NotificationTypeServer + .getType("notification.test.pending")); + ns.setTargetUser(instance.getEntity()); + ns.write2DB(); + assertEquals(1, instance.getPendingNotifications().size()); + ns.setAcknowledgeDate(new Date()); + ns.write2DB(); + assertEquals(0, instance.getPendingNotifications().size()); + } + + /** + * Test of getUser method, of class VMUserServer. + * + * @throws java.lang.Exception + */ + @Test + public void testGetUser() throws Exception { + System.out.println("getUser"); + String username = "test"; + String password = "test"; + String name = "Test"; + String lastname = "User"; + String email = "test.user@test.com"; + VMUserServer instance = new VMUserServer(username, password, name, + lastname, email); + instance.write2DB(); + assertNotNull(VMUserServer.getUser(username, password, true)); + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/server/core/VersionListenerIT.java b/VM-Core/src/test/java/com/validation/manager/core/server/core/VersionListenerIT.java deleted file mode 100644 index 2c8a6c9e..00000000 --- a/VM-Core/src/test/java/com/validation/manager/core/server/core/VersionListenerIT.java +++ /dev/null @@ -1,82 +0,0 @@ -/* - * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.validation.manager.core.server.core; - -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.db.Requirement; -import com.validation.manager.core.db.controller.RequirementJpaController; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.test.AbstractVMTestCase; -import static junit.framework.TestCase.*; -import org.junit.Test; -import org.openide.util.Exceptions; - -/** - * - * @author Javier Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class VersionListenerIT extends AbstractVMTestCase { - - /** - * Test of onChange method, of class VersionListener. - */ - @Test - public void testOnChange() { - System.out.println("onChange"); - DataBaseManager.setVersioningEnabled(true); - int count = 0; - int max = 10; - Requirement entity = new Requirement("SRS0001", "Description " - + (++count)); - RequirementJpaController controller - = new RequirementJpaController(DataBaseManager - .getEntityManagerFactory()); - assertEquals(0, controller.findRequirementEntities().size()); - controller.create(entity); - assertEquals(count, controller.findRequirementEntities().size()); - for (int i = 0; i < max; i++) { - try { - System.out.println("Modification: " + (i + 1)); - entity.setDescription("Description " + (++count)); - controller.edit(entity); - } - catch (NonexistentEntityException ex) { - Exceptions.printStackTrace(ex); - fail(); - } - catch (Exception ex) { - Exceptions.printStackTrace(ex); - fail(); - } - } - assertEquals(max + 1, controller.getRequirementCount()); - Requirement prev = null; - int x = 0; -// for (Requirement r : controller.findRequirementEntities()) { -// assertNotNull(r.getModificationTime()); -// assertNotNull(r.getDescription()); -// assertEquals(x == 0, r.isDirty()); -// if (x > 0) { -// //First one is the oldest one (version 0.0.max+1) -// if (prev != null) { -// assertTrue(r.compareTo(prev) > 0); -// } -// prev = r; -// } -// x++; -// } - } -} diff --git a/VM-Core/src/test/java/com/validation/manager/core/tool/ToolTest.java b/VM-Core/src/test/java/com/validation/manager/core/tool/ToolTest.java new file mode 100644 index 00000000..0187141a --- /dev/null +++ b/VM-Core/src/test/java/com/validation/manager/core/tool/ToolTest.java @@ -0,0 +1,100 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.validation.manager.core.tool; + +import com.validation.manager.core.server.core.TestCaseExecutionServer; +import com.validation.manager.core.server.core.TestCaseServer; +import com.validation.manager.test.AbstractVMTestCase; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import javax.swing.ImageIcon; +import static junit.framework.TestCase.*; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ToolTest extends AbstractVMTestCase { + + /** + * Test of createImageIcon method, of class Tool. + */ + @Test + public void testCreateImageIcon_String_String() { + System.out.println("createImageIcon"); + String path = "/com/validation/manager/resources/icons/VMSmall.png"; + String description = "Test"; + ImageIcon result = Tool.createImageIcon(path, description); + assertNotNull(result); + } + + /** + * Test of createImageIcon method, of class Tool. + */ + @Test + public void testCreateImageIcon_3args() { + System.out.println("createImageIcon"); + String path = "/com/validation/manager/resources/icons/VMSmall.png"; + String description = "Test"; + ImageIcon result = Tool.createImageIcon(path, description, Tool.class); + assertNotNull(result); + } + + /** + * Test of removeDuplicates method, of class Tool. + */ + @Test + public void testRemoveDuplicates() { + System.out.println("removeDuplicates"); + List list = new ArrayList<>(); + list.add(1); + list.add(2); + list.add(2); + list.add(2); + list.add(2); + list.add(3); + Tool.removeDuplicates(list); + assertEquals(3, list.size()); + } + + /** + * Test of extractTCE method, of class Tool. + * + * @throws java.lang.Exception + */ + @Test + public void testExtractTCE() throws Exception { + System.out.println("extractTCE"); + TestCaseExecutionServer tce = new TestCaseExecutionServer("Test Name", + "Test Scope"); + TestCaseServer tc = new TestCaseServer("Test Case", new Date()); + tc.write2DB(); + tce.addTestCase(tc); + tce.write2DB(); + String key = "tce-" + tce.getId() + "-" + tc.getId(); + TCEExtraction r = Tool.extractTCE(key); + assertEquals(tce.getId(), r.getTestCaseExecution().getId()); + try { + Tool.extractTCE(key + 1); + fail(); + } + catch (Exception ex) { + //Expected + } + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/tool/table/extractor/TableExtractorTest.java b/VM-Core/src/test/java/com/validation/manager/core/tool/table/extractor/TableExtractorTest.java index 62979467..baa4c9bc 100644 --- a/VM-Core/src/test/java/com/validation/manager/core/tool/table/extractor/TableExtractorTest.java +++ b/VM-Core/src/test/java/com/validation/manager/core/tool/table/extractor/TableExtractorTest.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,77 +13,92 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.core.tool.table.extractor; - -import java.io.File; -import static java.lang.System.getProperty; -import java.util.List; -import javax.swing.table.DefaultTableModel; -import org.junit.Test; -import static org.junit.Assert.*; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class TableExtractorTest { - - /** - * Test of extractTables method, of class TableExtractor. - * - * @throws java.lang.Exception - */ - @Test - public void testExtractTables() throws Exception { - System.out.println("extractTables"); - String name = TableExtractorTest.class.getCanonicalName(); - name = name.substring(0, name.lastIndexOf(".")); - name = name.replace(".", getProperty("file.separator")); - File file = new File(getProperty("user.dir") - + getProperty("file.separator") + "src" - + getProperty("file.separator") + "test" - + getProperty("file.separator") + "java" - + getProperty("file.separator") - + name - + getProperty("file.separator") + "Tables.docx"); - assert file.exists(); - TableExtractor te = new TableExtractor(file); - List tables = te.extractTables(); - assertEquals(2, tables.size()); - for (DefaultTableModel model : tables) { - //Has header - assertEquals(4, model.getRowCount()); - assertEquals(5, model.getColumnCount()); - } - file = new File(getProperty("user.dir") - + getProperty("file.separator") + "src" - + getProperty("file.separator") + "test" - + getProperty("file.separator") + "java" - + getProperty("file.separator") - + name - + getProperty("file.separator") + "Tables.xls"); - assert file.exists(); - te = new TableExtractor(file); - tables = te.extractTables(); - assertEquals(1, tables.size()); - for (DefaultTableModel model : tables) { - assertEquals(3, model.getRowCount()); - assertEquals(3, model.getColumnCount()); - } - file = new File(getProperty("user.dir") - + getProperty("file.separator") + "src" - + getProperty("file.separator") + "test" - + getProperty("file.separator") + "java" - + getProperty("file.separator") - + name - + getProperty("file.separator") + "Tables.xlsx"); - assert file.exists(); - te = new TableExtractor(file); - tables = te.extractTables(); - assertEquals(1, tables.size()); - for (DefaultTableModel model : tables) { - assertEquals(3, model.getRowCount()); - assertEquals(3, model.getColumnCount()); - } - } -} +package com.validation.manager.core.tool.table.extractor; + +import java.io.File; +import static java.lang.System.getProperty; +import java.util.List; +import javax.swing.table.DefaultTableModel; +import static org.junit.Assert.*; +import org.junit.Test; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class TableExtractorTest { + + /** + * Test of extractTables method, of class TableExtractor. + * + * @throws java.lang.Exception + */ + @Test + public void testExtractTables() throws Exception { + System.out.println("extractTables"); + String name = TableExtractorTest.class.getCanonicalName(); + name = name.substring(0, name.lastIndexOf(".")); + name = name.replace(".", getProperty("file.separator")); + File file = new File(getProperty("user.dir") + + getProperty("file.separator") + "src" + + getProperty("file.separator") + "test" + + getProperty("file.separator") + "java" + + getProperty("file.separator") + + name + + getProperty("file.separator") + "Tables.docx"); + assert file.exists(); + TableExtractor te = new TableExtractor(file); + List tables = te.extractTables(); + assertEquals(2, tables.size()); + for (DefaultTableModel model : tables) { + //Has header + assertEquals(4, model.getRowCount()); + assertEquals(5, model.getColumnCount()); + } + file = new File(getProperty("user.dir") + + getProperty("file.separator") + "src" + + getProperty("file.separator") + "test" + + getProperty("file.separator") + "java" + + getProperty("file.separator") + + name + + getProperty("file.separator") + "Tables.xls"); + assert file.exists(); + te = new TableExtractor(file); + tables = te.extractTables(); + assertEquals(1, tables.size()); + for (DefaultTableModel model : tables) { + assertEquals(3, model.getRowCount()); + assertEquals(3, model.getColumnCount()); + } + file = new File(getProperty("user.dir") + + getProperty("file.separator") + "src" + + getProperty("file.separator") + "test" + + getProperty("file.separator") + "java" + + getProperty("file.separator") + + name + + getProperty("file.separator") + "Tables.xlsx"); + assert file.exists(); + te = new TableExtractor(file); + tables = te.extractTables(); + assertEquals(1, tables.size()); + for (DefaultTableModel model : tables) { + assertEquals(3, model.getRowCount()); + assertEquals(3, model.getColumnCount()); + } + file = new File(getProperty("user.dir") + + getProperty("file.separator") + "src" + + getProperty("file.separator") + "test" + + getProperty("file.separator") + "java" + + getProperty("file.separator") + + name + + getProperty("file.separator") + "Tables.xlsm"); + assert file.exists(); + te = new TableExtractor(file); + tables = te.extractTables(); + assertEquals(1, tables.size()); + for (DefaultTableModel model : tables) { + assertEquals(3, model.getRowCount()); + assertEquals(3, model.getColumnCount()); + } + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/core/tool/table/extractor/Tables.xlsm b/VM-Core/src/test/java/com/validation/manager/core/tool/table/extractor/Tables.xlsm new file mode 100644 index 0000000000000000000000000000000000000000..e72a00a6a5dd60beb19158b4c9cad79a229db678 GIT binary patch literal 8873 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 literal 0 HcmV?d00001 diff --git a/VM-Core/src/test/java/com/validation/manager/test/AbstractVMTestCase.java b/VM-Core/src/test/java/com/validation/manager/test/AbstractVMTestCase.java index b677a25d..ae7f3bb4 100755 --- a/VM-Core/src/test/java/com/validation/manager/test/AbstractVMTestCase.java +++ b/VM-Core/src/test/java/com/validation/manager/test/AbstractVMTestCase.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,203 +13,195 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.test; - -import com.validation.manager.core.DBState; -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.history.Auditable; -import com.validation.manager.core.db.History; -import com.validation.manager.core.db.HistoryField; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.VmUserJpaController; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.history.Versionable; -import com.validation.manager.core.server.core.VMUserServer; -import static com.validation.manager.core.tool.MD5.encrypt; -import static com.validation.manager.test.TestHelper.deleteUser; -import static java.lang.Class.forName; -import java.lang.reflect.Field; -import java.sql.Connection; -import java.sql.SQLException; -import java.sql.Statement; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.logging.Level; -import java.util.logging.Logger; -import javax.sql.DataSource; -import junit.framework.TestCase; -import org.apache.commons.lang3.reflect.FieldUtils; -import org.h2.jdbcx.JdbcDataSource; -import org.junit.After; -import org.junit.Before; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public abstract class AbstractVMTestCase extends TestCase { - - protected VmUser designer, tester, leader; - /** - * Parameters for queries. - */ - protected HashMap parameters = new HashMap<>(); - /** - * Query results. - */ - protected List result; - public static boolean deleteDatabase = true; - private static final Logger LOG - = Logger.getLogger(AbstractVMTestCase.class.getSimpleName()); - - @Before - @Override - protected void setUp() throws Exception { - LOG.info("Setting up database!"); - DataBaseManager.setPersistenceUnitName("TestVMPU"); - assertEquals(DBState.VALID, DataBaseManager.getState()); - postSetUp(); - LOG.info("Done!"); - } - - @After - @Override - protected void tearDown() throws Exception { - LOG.info("Deleting database!"); - deleteTestUsers(); - Connection conn = null; - Statement stmt = null; - try { - Map properties - = DataBaseManager.getEntityManagerFactory() - .getProperties(); - DataSource ds = new JdbcDataSource(); - ((JdbcDataSource) ds).setPassword((String) properties - .get("javax.persistence.jdbc.password")); - ((JdbcDataSource) ds).setUser((String) properties - .get("javax.persistence.jdbc.user")); - ((JdbcDataSource) ds).setURL((String) properties - .get("javax.persistence.jdbc.url")); - //Load the H2 driver - forName("org.h2.Driver"); - conn = ds.getConnection(); - stmt = conn.createStatement(); - stmt.executeUpdate("DROP ALL OBJECTS DELETE FILES"); - } - catch (SQLException | ClassNotFoundException ex) { - LOG.log(Level.SEVERE, - null, ex); - } - finally { - try { - if (stmt != null) { - stmt.close(); - } - } - catch (SQLException ex) { - fail(); - } - try { - if (conn != null) { - conn.close(); - } - } - catch (SQLException ex) { - fail(); - } - } - DataBaseManager.close(); - postTearDown(); - LOG.info("Done!"); - } - - protected void createTestUsers() { - try { - VMUserServer temp = new VMUserServer("test1", - "password", "test@test.com", "first", "last"); - temp.write2DB(); - designer = new VmUserJpaController(DataBaseManager - .getEntityManagerFactory()) - .findVmUser(temp.getId()); - temp = new VMUserServer("test2", - "password", "test@test.com", "first", "last"); - temp.write2DB(); - tester = new VmUserJpaController(DataBaseManager - .getEntityManagerFactory()) - .findVmUser(temp.getId()); - temp = new VMUserServer("test3", - encrypt("password"), "test@test.com", "first", "last"); - temp.write2DB(); - leader = new VmUserJpaController(DataBaseManager - .getEntityManagerFactory()) - .findVmUser(temp.getId()); - LOG.log(Level.INFO, "Done!"); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - - /** - * Code to be performed after set up. - */ - protected void postSetUp() { - - } - - /** - * Code to be performed after set teardown. - */ - protected void postTearDown() { - - } - - protected void deleteTestUsers() { - try { - deleteUser(designer); - deleteUser(tester); - deleteUser(leader); - designer = null; - tester = null; - leader = null; - } - catch (IllegalOrphanException | NonexistentEntityException ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - - public List getAuditableFields(Versionable v) { - List r = new ArrayList<>(); - FieldUtils.getFieldsListWithAnnotation(v.getClass(), Auditable.class) - .stream().filter((field) - -> (field.isAnnotationPresent(Auditable.class))) - .forEachOrdered((field) -> { - r.add(field); - }); - return r; - } - - public boolean checkHistory(Versionable v) { - History current = v.getHistoryList().get(v.getHistoryList().size() - 1); - List af = getAuditableFields(v); - assertEquals(af.size(), current.getHistoryFieldList().size()); - assertTrue(af.size() > 0); - for (HistoryField hf : current.getHistoryFieldList()) { - try { - //Compare audit field vs. the record in history. - Object o = FieldUtils.readField(FieldUtils.getField(v.getClass(), - hf.getFieldName(), true), v); - if (!o.toString().equals(hf.getFieldValue())) { - return false; - } - } - catch (SecurityException | IllegalArgumentException | IllegalAccessException ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - return true; - } -} +package com.validation.manager.test; + +import com.validation.manager.core.DBState; +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.db.History; +import com.validation.manager.core.db.HistoryField; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.VmUserJpaController; +import com.validation.manager.core.history.Auditable; +import com.validation.manager.core.history.Versionable; +import com.validation.manager.core.server.core.VMUserServer; +import static com.validation.manager.core.tool.MD5.encrypt; +import static java.lang.Class.forName; +import java.lang.reflect.Field; +import java.sql.Connection; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; +import javax.sql.DataSource; +import junit.framework.TestCase; +import org.apache.commons.lang3.reflect.FieldUtils; +import org.h2.jdbcx.JdbcDataSource; +import org.junit.After; +import org.junit.Before; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public abstract class AbstractVMTestCase extends TestCase { + + protected VmUser designer, tester, leader; + /** + * Parameters for queries. + */ + protected HashMap parameters = new HashMap<>(); + /** + * Query results. + */ + protected List result; + public static boolean deleteDatabase = true; + private static final Logger LOG + = Logger.getLogger(AbstractVMTestCase.class.getSimpleName()); + + @Before + @Override + protected void setUp() throws Exception { + LOG.info("Setting up database!"); + DataBaseManager.setPersistenceUnitName("TestVMPU"); + assertEquals(DBState.VALID, DataBaseManager.getState()); + postSetUp(); + LOG.info("Done!"); + } + + @After + @Override + protected void tearDown() throws Exception { + LOG.info("Deleting database!"); + deleteTestUsers(); + Connection conn = null; + Statement stmt = null; + try { + Map properties + = DataBaseManager.getEntityManagerFactory() + .getProperties(); + DataSource ds = new JdbcDataSource(); + ((JdbcDataSource) ds).setPassword((String) properties + .get("javax.persistence.jdbc.password")); + ((JdbcDataSource) ds).setUser((String) properties + .get("javax.persistence.jdbc.user")); + ((JdbcDataSource) ds).setURL((String) properties + .get("javax.persistence.jdbc.url")); + //Load the H2 driver + forName("org.h2.Driver"); + conn = ds.getConnection(); + stmt = conn.createStatement(); + stmt.executeUpdate("DROP ALL OBJECTS DELETE FILES"); + } + catch (SQLException | ClassNotFoundException ex) { + LOG.log(Level.SEVERE, + null, ex); + } + finally { + try { + if (stmt != null) { + stmt.close(); + } + } + catch (SQLException ex) { + fail(); + } + try { + if (conn != null) { + conn.close(); + } + } + catch (SQLException ex) { + fail(); + } + } + DataBaseManager.close(); + postTearDown(); + LOG.info("Done!"); + } + + protected void createTestUsers() { + try { + VMUserServer temp = new VMUserServer("test1", + "password", "test@test.com", "first", "last"); + temp.write2DB(); + designer = new VmUserJpaController(DataBaseManager + .getEntityManagerFactory()) + .findVmUser(temp.getId()); + temp = new VMUserServer("test2", + "password", "test@test.com", "first", "last"); + temp.write2DB(); + tester = new VmUserJpaController(DataBaseManager + .getEntityManagerFactory()) + .findVmUser(temp.getId()); + temp = new VMUserServer("test3", + encrypt("password"), "test@test.com", "first", "last"); + temp.write2DB(); + leader = new VmUserJpaController(DataBaseManager + .getEntityManagerFactory()) + .findVmUser(temp.getId()); + LOG.log(Level.INFO, "Done!"); + } + catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + + /** + * Code to be performed after set up. + */ + protected void postSetUp() { + + } + + /** + * Code to be performed after set teardown. + */ + protected void postTearDown() { + + } + + protected void deleteTestUsers() { + designer = null; + tester = null; + leader = null; + } + + public List getAuditableFields(Versionable v) { + List r = new ArrayList<>(); + FieldUtils.getFieldsListWithAnnotation(v.getClass(), Auditable.class) + .stream().filter((field) + -> (field.isAnnotationPresent(Auditable.class))) + .forEachOrdered((field) -> { + r.add(field); + }); + return r; + } + + public boolean checkHistory(Versionable v) { + History current = v.getHistoryList().get(v.getHistoryList().size() - 1); + List af = getAuditableFields(v); + assertEquals(af.size(), current.getHistoryFieldList().size()); + assertTrue(af.size() > 0); + for (HistoryField hf : current.getHistoryFieldList()) { + try { + //Compare audit field vs. the record in history. + Object o = FieldUtils.readField(FieldUtils.getField(v.getClass(), + hf.getFieldName(), true), v); + if (!Versionable.fieldMatchHistory(hf, o)) { + return false; + } + } + catch (SecurityException | IllegalArgumentException | IllegalAccessException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + v.getHistoryList().forEach(h -> { + LOG.info(h.toString()); + }); + return true; + } +} diff --git a/VM-Core/src/test/java/com/validation/manager/test/TestHelper.java b/VM-Core/src/test/java/com/validation/manager/test/TestHelper.java index 695c2a5e..67712e52 100755 --- a/VM-Core/src/test/java/com/validation/manager/test/TestHelper.java +++ b/VM-Core/src/test/java/com/validation/manager/test/TestHelper.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,223 +13,200 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.validation.manager.test; - -import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; -import com.validation.manager.core.VMException; -import com.validation.manager.core.db.Project; -import com.validation.manager.core.db.Requirement; -import com.validation.manager.core.db.RequirementSpec; -import com.validation.manager.core.db.RequirementSpecNode; -import com.validation.manager.core.db.RequirementSpecNodePK; -import com.validation.manager.core.db.Step; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.TestPlan; -import com.validation.manager.core.db.TestProject; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.ProjectJpaController; -import com.validation.manager.core.db.controller.RequirementJpaController; -import com.validation.manager.core.db.controller.UserStatusJpaController; -import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; -import com.validation.manager.core.server.core.ProjectServer; -import com.validation.manager.core.server.core.RequirementServer; -import com.validation.manager.core.server.core.RequirementSpecNodeServer; -import com.validation.manager.core.server.core.RequirementSpecServer; -import com.validation.manager.core.server.core.StepServer; -import com.validation.manager.core.server.core.TestCaseServer; -import com.validation.manager.core.server.core.TestPlanServer; -import com.validation.manager.core.server.core.TestProjectServer; -import com.validation.manager.core.server.core.VMUserServer; -import java.util.ArrayList; -import java.util.Date; -import java.util.logging.Level; -import java.util.logging.Logger; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class TestHelper { - - private static final Logger LOG - = Logger.getLogger(TestHelper.class.getName()); - - public static VmUser createUser(String name, String pass, String email, - String first, String last) throws Exception { - VMUserServer temp = new VMUserServer(name, - pass, first, last, email); - temp.setUserStatusId(new UserStatusJpaController( - getEntityManagerFactory()).findUserStatus(1)); - temp.write2DB(); - return temp.getEntity(); - } - - public static void deleteUser(VmUser user) throws NonexistentEntityException, - IllegalOrphanException { - if (user != null) { - VMUserServer.deleteUser(user); - } - } - - public static Project createProject(String name, String notes) { - ProjectServer ps = new ProjectServer(name, notes); - try { - ps.write2DB(); - } - catch (IllegalOrphanException ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - catch (NonexistentEntityException ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - assertTrue(ps.getEntity() != null); - return ps.getEntity(); - } - - public static void destroyProject(Project p) throws IllegalOrphanException, - NonexistentEntityException, VMException { - ProjectServer.deleteProject(p); - assertTrue(new ProjectJpaController( - getEntityManagerFactory()).findProject(p.getId()) == null); - } - - public static TestCase createTestCase(String name, String summary) - throws PreexistingEntityException, Exception { - TestCaseServer tc = new TestCaseServer(name, new Date()); - tc.setRiskControlHasTestCaseList(new ArrayList<>()); - tc.setActive(true); - tc.setIsOpen(true); - tc.setSummary(summary.getBytes()); - tc.write2DB(); - return tc.getEntity(); - } - - public static Requirement createRequirement(String id, String desc, - RequirementSpecNodePK p, String notes, int requirementType, - int requirementStatus) throws Exception { - RequirementServer req = new RequirementServer(id, desc, p, notes, - requirementType, requirementStatus); - req.write2DB(); - assert req.getEntity().getRequirementSpecNode() != null; - return req.getEntity(); - } - - public static void destroyRequirement(Requirement r) - throws NonexistentEntityException { - try { - RequirementServer.deleteRequirement(r); - assertTrue(new RequirementJpaController( - getEntityManagerFactory()) - .findRequirement(r.getId()) == null); - } - catch (IllegalOrphanException ex) { - LOG.log(Level.SEVERE, null, ex); - fail(); - } - } - - public static TestCase addStep(TestCase tc, int sequence, - String text, String note, String result) throws PreexistingEntityException, - Exception { - TestCaseServer tcs = new TestCaseServer(tc.getId()); - int amount = tcs.getStepList().size(); - tcs.addStep(sequence, text, note, note, null); - assertEquals(amount + 1, tcs.getStepList().size()); - return tcs.getEntity(); - } - - public static TestProject createTestProject(String name) - throws IllegalOrphanException, NonexistentEntityException, - Exception { - TestProjectServer tps = new TestProjectServer("Test Project", true); - tps.write2DB(); - return tps.getEntity(); - } - - public static TestPlan createTestPlan(TestProject tp, String notes, - boolean active, boolean open) throws PreexistingEntityException, - Exception { - TestPlanServer plan = new TestPlanServer(tp, active, open); - plan.setNotes(notes); - plan.setTestProject(tp); - plan.write2DB(); - tp.getTestPlanList().add(plan.getEntity()); - return plan.getEntity(); - } - - public static void addTestCaseToPlan(TestPlan plan, TestCase testCase) - throws PreexistingEntityException, Exception { - int testInPlan = plan.getTestCaseList().size(); - TestPlanServer tps = new TestPlanServer(plan); - tps.getTestCaseList().add(testCase); - tps.write2DB(); - tps.update(plan, tps); - testCase.getTestPlanList().add(plan); - assertTrue(plan.getTestCaseList().size() > testInPlan); - } - - public static RequirementSpec createRequirementSpec(String name, - String description, Project project, int specLevelId) - throws Exception { - RequirementSpecServer rss = new RequirementSpecServer(name, description, - project.getId(), specLevelId); - rss.write2DB(); - project.getRequirementSpecList().add(rss.getEntity()); - new ProjectServer(project).write2DB(); - return rss.getEntity(); - } - - public static RequirementSpecNode createRequirementSpecNode( - RequirementSpec rss, String name, String description, String scope) - throws Exception { - RequirementSpecNodeServer rsns = new RequirementSpecNodeServer(rss, - name, description, scope); - rsns.write2DB(); - return rsns.getEntity(); - } - - public static void addTestProjectToProject(TestProject tp, Project project) - throws IllegalOrphanException, NonexistentEntityException, - Exception { - ProjectServer ps = new ProjectServer(project); - int current = ps.getTestProjectList().size(); - ps.getTestProjectList().add(tp); - ps.write2DB(); - assertTrue(ps.getEntity().getTestProjectList().size() > current); - tp.getProjectList().add(project); - } - - public static void addRequirementToStep(Step step, Requirement req) - throws Exception { - StepServer ss = new StepServer(step); - ss.addRequirement(req); - ss.write2DB(); - } - - public static Project addProject(Project root, String name, String notes) - throws NonexistentEntityException, Exception { - Project sub = createProject(name, notes); - ProjectServer ps = new ProjectServer(root); - ps.getProjectList().add(sub); - ps.write2DB(); - return new ProjectServer(sub).getEntity(); - } - - public static Requirement addChildToRequirement(Requirement parent, - Requirement child) throws Exception { - RequirementServer rs = new RequirementServer(parent); - rs.addChildRequirement(child); - return rs.getEntity(); - } -} +package com.validation.manager.test; + +import static com.validation.manager.core.DataBaseManager.getEntityManagerFactory; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.Project; +import com.validation.manager.core.db.Requirement; +import com.validation.manager.core.db.RequirementSpec; +import com.validation.manager.core.db.RequirementSpecNode; +import com.validation.manager.core.db.RequirementSpecNodePK; +import com.validation.manager.core.db.Step; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.TestPlan; +import com.validation.manager.core.db.TestProject; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.RequirementJpaController; +import com.validation.manager.core.db.controller.UserStatusJpaController; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.db.controller.exceptions.PreexistingEntityException; +import com.validation.manager.core.server.core.ProjectServer; +import com.validation.manager.core.server.core.RequirementServer; +import com.validation.manager.core.server.core.RequirementSpecNodeServer; +import com.validation.manager.core.server.core.RequirementSpecServer; +import com.validation.manager.core.server.core.StepServer; +import com.validation.manager.core.server.core.TestCaseServer; +import com.validation.manager.core.server.core.TestPlanServer; +import com.validation.manager.core.server.core.TestProjectServer; +import com.validation.manager.core.server.core.VMUserServer; +import java.util.ArrayList; +import java.util.Date; +import java.util.logging.Level; +import java.util.logging.Logger; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class TestHelper { + + private static final Logger LOG + = Logger.getLogger(TestHelper.class.getName()); + + public static VmUser createUser(String name, String pass, String email, + String first, String last) throws Exception { + VMUserServer temp = new VMUserServer(name, + pass, first, last, email); + temp.setUserStatusId(new UserStatusJpaController( + getEntityManagerFactory()).findUserStatus(1)); + temp.write2DB(); + return temp.getEntity(); + } + + public static Project createProject(String name, String notes) { + ProjectServer ps = new ProjectServer(name, notes); + try { + ps.write2DB(); + } + catch (VMException ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + assertTrue(ps.getEntity() != null); + return ps.getEntity(); + } + + public static TestCase createTestCase(String name, String summary) + throws PreexistingEntityException, Exception { + TestCaseServer tc = new TestCaseServer(name, new Date()); + tc.setRiskControlHasTestCaseList(new ArrayList<>()); + tc.setActive(true); + tc.setIsOpen(true); + tc.setSummary(summary.getBytes()); + tc.write2DB(); + return tc.getEntity(); + } + + public static Requirement createRequirement(String id, String desc, + RequirementSpecNodePK p, String notes, int requirementType, + int requirementStatus) throws Exception { + RequirementServer req = new RequirementServer(id, desc, p, notes, + requirementType, requirementStatus); + req.write2DB(); + assert req.getEntity().getRequirementSpecNode() != null; + return req.getEntity(); + } + + public static void destroyRequirement(Requirement r) + throws NonexistentEntityException { + try { + RequirementServer.deleteRequirement(r); + assertTrue(new RequirementJpaController( + getEntityManagerFactory()) + .findRequirement(r.getId()) == null); + } + catch (IllegalOrphanException ex) { + LOG.log(Level.SEVERE, null, ex); + fail(); + } + } + + public static TestCase addStep(TestCase tc, int sequence, + String text, String note, String result) throws PreexistingEntityException, + Exception { + TestCaseServer tcs = new TestCaseServer(tc.getId()); + int amount = tcs.getStepList().size(); + tcs.addStep(sequence, text, note, note, null); + assertEquals(amount + 1, tcs.getStepList().size()); + return tcs.getEntity(); + } + + public static TestProject createTestProject(String name) + throws IllegalOrphanException, NonexistentEntityException, + Exception { + TestProjectServer tps = new TestProjectServer("Test Project", true); + tps.write2DB(); + return tps.getEntity(); + } + + public static TestPlan createTestPlan(TestProject tp, String notes, + boolean active, boolean open) throws PreexistingEntityException, + Exception { + TestPlanServer plan = new TestPlanServer(tp, active, open); + plan.setNotes(notes); + plan.setTestProject(tp); + plan.write2DB(); + tp.getTestPlanList().add(plan.getEntity()); + return plan.getEntity(); + } + + public static void addTestCaseToPlan(TestPlan plan, TestCase testCase) + throws PreexistingEntityException, Exception { + int testInPlan = plan.getTestCaseList().size(); + TestPlanServer tps = new TestPlanServer(plan); + tps.getTestCaseList().add(testCase); + tps.write2DB(); + tps.update(plan, tps); + testCase.getTestPlanList().add(plan); + assertTrue(plan.getTestCaseList().size() > testInPlan); + } + + public static RequirementSpec createRequirementSpec(String name, + String description, Project project, int specLevelId) + throws Exception { + RequirementSpecServer rss = new RequirementSpecServer(name, description, + project.getId(), specLevelId); + rss.write2DB(); + project.getRequirementSpecList().add(rss.getEntity()); + new ProjectServer(project).write2DB(); + return rss.getEntity(); + } + + public static RequirementSpecNode createRequirementSpecNode( + RequirementSpec rss, String name, String description, String scope) + throws Exception { + RequirementSpecNodeServer rsns = new RequirementSpecNodeServer(rss, + name, description, scope); + rsns.write2DB(); + return rsns.getEntity(); + } + + public static void addTestProjectToProject(TestProject tp, Project project) + throws IllegalOrphanException, NonexistentEntityException, + Exception { + ProjectServer ps = new ProjectServer(project); + int current = ps.getTestProjectList().size(); + ps.getTestProjectList().add(tp); + ps.write2DB(); + assertTrue(ps.getEntity().getTestProjectList().size() > current); + tp.getProjectList().add(project); + } + + public static void addRequirementToStep(Step step, Requirement req) + throws Exception { + StepServer ss = new StepServer(step); + ss.addRequirement(req); + ss.write2DB(); + } + + public static Project addProject(Project root, String name, String notes) + throws NonexistentEntityException, Exception { + Project sub = createProject(name, notes); + ProjectServer ps = new ProjectServer(root); + ps.getProjectList().add(sub); + ps.write2DB(); + return new ProjectServer(sub).getEntity(); + } + + public static Requirement addChildToRequirement(Requirement parent, + Requirement child) throws Exception { + RequirementServer rs = new RequirementServer(parent); + rs.addChildRequirement(child); + return rs.getEntity(); + } +} diff --git a/Validation-Manager-Web/pom.xml b/Validation-Manager-Web/pom.xml index b1968668..ba06e2c3 100644 --- a/Validation-Manager-Web/pom.xml +++ b/Validation-Manager-Web/pom.xml @@ -4,7 +4,7 @@ Validation-Manager net.sourceforge.javydreamercsw - 0.3.2 + 0.3.3 Validation-Manager-Web @@ -112,6 +112,11 @@ jodconverter-core 4.0.0-RELEASE + + org.apache.poi + poi-scratchpad + ${poi.version} + com.vaadin @@ -136,18 +141,13 @@ pl.pdfviewer pdfviewer - 1.3.1 + 1.3.2 org.vaadin.addons imageviewer 0.6.0.v8 - - org.apache.poi - poi-scratchpad - ${poi.version} - de.steinwedel.vaadin.addon messagebox diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/LoginDialog.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/LoginDialog.java index b3260abe..94d59fd1 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/LoginDialog.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/LoginDialog.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,141 +13,191 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web; - -import com.vaadin.data.validator.StringLengthValidator; -import com.vaadin.event.Action; -import com.vaadin.event.Action.Handler; -import com.vaadin.event.ShortcutAction; -import com.vaadin.server.Page; -import com.vaadin.ui.Alignment; -import com.vaadin.ui.Button; -import com.vaadin.ui.Button.ClickEvent; -import com.vaadin.ui.FormLayout; -import com.vaadin.ui.HorizontalLayout; -import com.vaadin.ui.Notification; -import com.vaadin.ui.PasswordField; -import com.vaadin.ui.TextField; -import com.validation.manager.core.api.internationalization.InternationalizationProvider; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.server.core.VMUserServer; -import org.openide.util.Lookup; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@SuppressWarnings("serial") -public final class LoginDialog extends VMWindow { - - private final ShortcutAction enterKey - = new ShortcutAction(Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate("general.login"), - ShortcutAction.KeyCode.ENTER, null); - - private final TextField name = new TextField(Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate("general.username")); - private final PasswordField password = new PasswordField(Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate("general.password")); - - private final Button loginButton = new Button(Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate("general.login"), - (ClickEvent event) -> { - tryToLogIn(); - }); - - private final Button cancelButton = new Button(Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate("general.cancel"), - (ClickEvent event) -> { - LoginDialog.this.close(); - }); - - public LoginDialog(ValidationManagerUI menu) { - super(menu, Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate("general.login")); - init(); - } - - public void init() { - //Layout - FormLayout layout = new FormLayout(); - setContent(layout); - HorizontalLayout hlayout = new HorizontalLayout(); - hlayout.addComponent(loginButton); - hlayout.addComponent(cancelButton); - layout.addComponent(name); - layout.addComponent(password); - name.focus(); - StringLengthValidator nameVal = new StringLengthValidator( - Lookup.getDefault() - .lookup(InternationalizationProvider.class). - translate("password.length.message")); - nameVal.setMinLength(5); - name.addValidator(nameVal); - name.setImmediate(true); - StringLengthValidator passVal = new StringLengthValidator( - Lookup.getDefault() - .lookup(InternationalizationProvider.class). - translate("password.empty.message")); - passVal.setMinLength(3); - password.addValidator(passVal); - password.setImmediate(true); - layout.addComponent(hlayout); - layout.setComponentAlignment(name, Alignment.TOP_LEFT); - layout.setComponentAlignment(password, Alignment.MIDDLE_LEFT); - layout.setComponentAlignment(hlayout, Alignment.BOTTOM_LEFT); - layout.setSpacing(true); - layout.setMargin(true); - - // Keyboard navigation - enter key is a shortcut to login - addActionHandler(new Handler() { - @Override - public Action[] getActions(Object target, Object sender) { - return new Action[]{enterKey}; - } - - @Override - public void handleAction(Action action, Object sender, - Object target) { - tryToLogIn(); - } - }); - } - - private void tryToLogIn() { - if (VMUserServer.validCredentials(name.getValue(), - password.getValue(), true)) { - VmUser user - = VMUserServer.getUser(name.getValue(), - password.getValue(), true); - if (menu != null) { - menu.setUser(new VMUserServer(user)); - } - close(); - } else { - if (menu != null) { - menu.setUser(null); - } - new Notification(Lookup.getDefault() - .lookup(InternationalizationProvider.class). - translate("general.login.invalid.title"), - Lookup.getDefault() - .lookup(InternationalizationProvider.class). - translate("general.login.invalid.message"), - Notification.Type.WARNING_MESSAGE, true) - .show(Page.getCurrent()); - password.setValue(""); - } - } - - public void clear() { - name.clear(); - password.clear(); - } -} +package net.sourceforge.javydreamercsw.validation.manager.web; + +import com.vaadin.data.validator.StringLengthValidator; +import com.vaadin.event.Action; +import com.vaadin.event.Action.Handler; +import com.vaadin.event.ShortcutAction; +import com.vaadin.server.Page; +import com.vaadin.ui.Alignment; +import com.vaadin.ui.Button; +import com.vaadin.ui.Button.ClickEvent; +import com.vaadin.ui.FormLayout; +import com.vaadin.ui.HorizontalLayout; +import com.vaadin.ui.Notification; +import com.vaadin.ui.PasswordField; +import com.vaadin.ui.TextField; +import com.vaadin.ui.UI; +import com.validation.manager.core.VMException; +import com.validation.manager.core.VMUI; +import com.validation.manager.core.api.internationalization.InternationalizationProvider; +import com.validation.manager.core.server.core.VMUserServer; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.openide.util.Lookup; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@SuppressWarnings("serial") +public final class LoginDialog extends VMWindow { + + private static final InternationalizationProvider TRANSLATOR + = Lookup.getDefault().lookup(InternationalizationProvider.class); + private static final Logger LOG + = Logger.getLogger(LoginDialog.class.getSimpleName()); + private final ShortcutAction enterKey + = new ShortcutAction(Lookup.getDefault() + .lookup(InternationalizationProvider.class) + .translate("general.login"), + ShortcutAction.KeyCode.ENTER, null); + + private final TextField name = new TextField(Lookup.getDefault() + .lookup(InternationalizationProvider.class) + .translate("general.username")); + private final PasswordField password = new PasswordField(Lookup.getDefault() + .lookup(InternationalizationProvider.class) + .translate("general.password")); + + private final Button loginButton = new Button(Lookup.getDefault() + .lookup(InternationalizationProvider.class) + .translate("general.login"), + (ClickEvent event) -> { + tryToLogIn(); + }); + + private final Button cancelButton = new Button(Lookup.getDefault() + .lookup(InternationalizationProvider.class) + .translate("general.cancel"), + (ClickEvent event) -> { + LoginDialog.this.close(); + }); + + public LoginDialog(ValidationManagerUI menu) { + super(menu, Lookup.getDefault() + .lookup(InternationalizationProvider.class) + .translate("general.login")); + init(); + } + + public void init() { + //Layout + FormLayout layout = new FormLayout(); + setContent(layout); + HorizontalLayout hlayout = new HorizontalLayout(); + hlayout.addComponent(loginButton); + hlayout.addComponent(cancelButton); + layout.addComponent(name); + layout.addComponent(password); + name.focus(); + StringLengthValidator nameVal = new StringLengthValidator( + Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("password.length.message")); + nameVal.setMinLength(5); + name.addValidator(nameVal); + name.setImmediate(true); + StringLengthValidator passVal = new StringLengthValidator( + Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("password.empty.message")); + passVal.setMinLength(3); + password.addValidator(passVal); + password.setImmediate(true); + layout.addComponent(hlayout); + layout.setComponentAlignment(name, Alignment.TOP_LEFT); + layout.setComponentAlignment(password, Alignment.MIDDLE_LEFT); + layout.setComponentAlignment(hlayout, Alignment.BOTTOM_LEFT); + layout.setSpacing(true); + layout.setMargin(true); + + // Keyboard navigation - enter key is a shortcut to login + addActionHandler(new Handler() { + @Override + public Action[] getActions(Object target, Object sender) { + return new Action[]{enterKey}; + } + + @Override + public void handleAction(Action action, Object sender, + Object target) { + tryToLogIn(); + } + }); + } + + private void tryToLogIn() { + try { + //Throws exception if credentials are wrong. + VMUserServer user = new VMUserServer(name.getValue(), + password.getValue()); + if (menu != null) { + switch (user.getUserStatusId().getId()) { + case 1: + //Everything OK + menu.setUser(user); + break; + case 2: + //TODO: Inactive. Right now no special behavior + menu.setUser(user); + break; + case 3: + //Locked + new Notification(Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("audit.user.account.lock"), + Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("menu.connection.error.user"), + Notification.Type.ERROR_MESSAGE, true) + .show(Page.getCurrent()); + break; + case 4: + //Password Aged + new Notification(Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("user.status.aged"), + Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("user.status.aged"), + Notification.Type.WARNING_MESSAGE, true) + .show(Page.getCurrent()); + menu.setUser(user); + //Open the profile page + ((VMUI) UI.getCurrent()).showTab("message.admin.userProfile"); + break; + default: + LOG.log(Level.SEVERE, "Unexpected User Status: {0}", + user.getUserStatusId().getId()); + Notification.show("Unexpected User Status", + "Unexpected User Status: " + + user.getUserStatusId().getId() + + "\n" + TRANSLATOR.translate("message.db.error"), + Notification.Type.ERROR_MESSAGE); + break; + } + } + close(); + } catch (VMException ex) { + if (menu != null) { + menu.setUser(null); + } + new Notification(Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("general.login.invalid.title"), + Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("general.login.invalid.message"), + Notification.Type.WARNING_MESSAGE, true) + .show(Page.getCurrent()); + password.setValue(""); + } + } + + public void clear() { + name.clear(); + password.clear(); + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/ValidationManagerUI.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/ValidationManagerUI.java index 43af4eb7..0263ef77 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/ValidationManagerUI.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/ValidationManagerUI.java @@ -164,9 +164,10 @@ import java.util.logging.Level; import java.util.logging.Logger; import javax.servlet.annotation.WebServlet; +import net.sourceforge.javydreamercsw.validation.manager.web.component.ByteToStringConverter; import net.sourceforge.javydreamercsw.validation.manager.web.dashboard.ExecutionDashboard; +import net.sourceforge.javydreamercsw.validation.manager.web.demo.DemoProvider; import net.sourceforge.javydreamercsw.validation.manager.web.importer.FileUploader; -import net.sourceforge.javydreamercsw.validation.manager.web.provider.DemoProvider; import net.sourceforge.javydreamercsw.validation.manager.web.provider.DesignerScreenProvider; import net.sourceforge.javydreamercsw.validation.manager.web.traceability.TraceMatrix; import net.sourceforge.javydreamercsw.validation.manager.web.wizard.assign.AssignUserStep; @@ -257,7 +258,7 @@ public void setUser(VMUserServer user) { user.setLocale(l.getLanguage()); try { user.write2DB(); - } catch (Exception ex) { + } catch (VMException ex) { LOG.log(Level.SEVERE, null, ex); } } else { @@ -529,7 +530,7 @@ public void wizardCancelled(WizardCancelledEvent event) { ess.getHistoryList().add(history.get(r)); }); ess.write2DB(); - } catch (Exception ex) { + } catch (VMException ex) { LOG.log(Level.SEVERE, null, ex); } }); @@ -1983,16 +1984,18 @@ private Component getMenu() { gl.addComponent(new Label(TRANSLATOR.translate("general.version") + ": " + getVersion()), 2, 2); if (getUser() != null) { + getUser().update(); //Logout button Button logout = new Button(TRANSLATOR.translate("general.logout")); logout.addClickListener((Button.ClickEvent event) -> { try { + user.update(); user.write2DB(); user = null; main = null; setLocale(Locale.ENGLISH); updateScreen(); - } catch (Exception ex) { + } catch (VMException ex) { LOG.log(Level.SEVERE, null, ex); } }); @@ -2818,8 +2821,7 @@ private Grid getHistoryTable(String title, String... fields) { Grid grid = new Grid(title); BeanItemContainer histories - = new BeanItemContainer<>(History.class - ); + = new BeanItemContainer<>(History.class); GeneratedPropertyContainer wrapperCont = new GeneratedPropertyContainer(histories); histories.addAll(historyItems); diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/admin/AdminScreenProvider.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/admin/AdminScreenProvider.java index cd99cc8c..e8785470 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/admin/AdminScreenProvider.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/admin/AdminScreenProvider.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,151 +13,565 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web.admin; - -import com.vaadin.data.Property; -import com.vaadin.data.fieldgroup.BeanFieldGroup; -import com.vaadin.data.fieldgroup.FieldGroup; -import com.vaadin.ui.Button; -import com.vaadin.ui.Component; -import com.vaadin.ui.Field; -import com.vaadin.ui.FormLayout; -import com.vaadin.ui.HorizontalLayout; -import com.vaadin.ui.HorizontalSplitPanel; -import com.vaadin.ui.Notification; -import com.vaadin.ui.Panel; -import com.vaadin.ui.TabSheet; -import com.vaadin.ui.TextArea; -import com.vaadin.ui.TextField; -import com.vaadin.ui.Tree; -import com.vaadin.ui.VerticalLayout; -import com.vaadin.ui.themes.ValoTheme; -import com.validation.manager.core.IMainContentProvider; -import com.validation.manager.core.api.internationalization.InternationalizationProvider; -import com.validation.manager.core.db.VmSetting; -import com.validation.manager.core.server.core.VMSettingServer; -import java.util.logging.Level; -import java.util.logging.Logger; -import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; -import net.sourceforge.javydreamercsw.validation.manager.web.provider.AbstractProvider; -import org.openide.util.Lookup; -import org.openide.util.lookup.ServiceProvider; - -@ServiceProvider(service = IMainContentProvider.class, position = 4) -public class AdminScreenProvider extends AbstractProvider { - - private static final Logger LOG - = Logger.getLogger(IMainContentProvider.class.getSimpleName()); - - @Override - public Component getContent() { - TabSheet adminSheet = new TabSheet(); - VerticalLayout layout = new VerticalLayout(); - //Build setting tab - VerticalLayout sl = new VerticalLayout(); - HorizontalSplitPanel split = new HorizontalSplitPanel(); - sl.addComponent(split); - //Build left side - Tree sTree = new Tree(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("general.settings")); - adminSheet.addTab(sl, Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("general.settings")); - VMSettingServer.getSettings().stream().map((s) -> { - sTree.addItem(s); - sTree.setChildrenAllowed(s, false); - return s; - }).forEachOrdered((s) -> { - sTree.setItemCaption(s, Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate(s.getSetting())); - }); - split.setFirstComponent(sTree); - layout.addComponent(adminSheet); - sTree.addValueChangeListener((Property.ValueChangeEvent event) -> { - if (sTree.getValue() instanceof VmSetting) { - split.setSecondComponent( - displaySetting((VmSetting) sTree.getValue())); - } - }); - layout.setId(getComponentCaption()); - return layout; - } - - @Override - public String getComponentCaption() { - return "admin.tab.name"; - } - - @Override - public boolean shouldDisplay() { - return ValidationManagerUI.getInstance().getUser() != null - && ValidationManagerUI.getInstance() - .checkRight("system.configuration"); - } - - private Component displaySetting(VmSetting s) { - Panel form = new Panel(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("setting.detail")); - FormLayout layout = new FormLayout(); - form.setContent(layout); - form.addStyleName(ValoTheme.FORMLAYOUT_LIGHT); - BeanFieldGroup binder = new BeanFieldGroup(s.getClass()); - binder.setItemDataSource(s); - Field id = (TextField) binder.buildAndBind(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("general.setting"), "setting"); - layout.addComponent(id); - Field bool = binder.buildAndBind(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("bool.value"), "boolVal"); - bool.setSizeFull(); - layout.addComponent(bool); - Field integerVal = binder.buildAndBind(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("int.value"), "intVal"); - integerVal.setSizeFull(); - layout.addComponent(integerVal); - Field longVal = binder.buildAndBind(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("long.val"), "longVal"); - longVal.setSizeFull(); - layout.addComponent(longVal); - Field stringVal = binder.buildAndBind(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("string.val"), "stringVal", - TextArea.class); - stringVal.setStyleName(ValoTheme.TEXTAREA_LARGE); - stringVal.setSizeFull(); - layout.addComponent(stringVal); - Button cancel = new Button(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("general.cancel")); - cancel.addClickListener((Button.ClickEvent event) -> { - binder.discard(); - }); - //Editing existing one - Button update = new Button(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("general.update")); - update.addClickListener((Button.ClickEvent event) -> { - try { - binder.commit(); - displaySetting(s); - } catch (FieldGroup.CommitException ex) { - LOG.log(Level.SEVERE, null, ex); - Notification.show(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("general.error.record.update"), - ex.getLocalizedMessage(), - Notification.Type.ERROR_MESSAGE); - } - }); - boolean blocked = !s.getSetting().startsWith("version."); - if (blocked) { - HorizontalLayout hl = new HorizontalLayout(); - hl.addComponent(update); - hl.addComponent(cancel); - layout.addComponent(hl); - } - binder.setBuffered(true); - binder.setReadOnly(false); - binder.bindMemberFields(form); - //The version settigns are not modifiable from the GUI - binder.setEnabled(blocked); - //Id is always blocked. - id.setEnabled(false); - form.setSizeFull(); - return form; - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.admin; + +import com.vaadin.data.Property; +import com.vaadin.data.fieldgroup.BeanFieldGroup; +import com.vaadin.data.fieldgroup.FieldGroup; +import com.vaadin.data.util.BeanItemContainer; +import com.vaadin.icons.VaadinIcons; +import com.vaadin.server.Sizeable; +import com.vaadin.shared.ui.grid.HeightMode; +import com.vaadin.ui.Button; +import com.vaadin.ui.ComboBox; +import com.vaadin.ui.Component; +import com.vaadin.ui.Field; +import com.vaadin.ui.FormLayout; +import com.vaadin.ui.Grid; +import com.vaadin.ui.Grid.SelectionMode; +import com.vaadin.ui.Grid.SingleSelectionModel; +import com.vaadin.ui.HorizontalLayout; +import com.vaadin.ui.HorizontalSplitPanel; +import com.vaadin.ui.Notification; +import com.vaadin.ui.Panel; +import com.vaadin.ui.TabSheet; +import com.vaadin.ui.TextArea; +import com.vaadin.ui.TextField; +import com.vaadin.ui.Tree; +import com.vaadin.ui.UI; +import com.vaadin.ui.VerticalLayout; +import com.vaadin.ui.themes.ValoTheme; +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.IMainContentProvider; +import com.validation.manager.core.VMUI; +import com.validation.manager.core.api.email.IEmailManager; +import com.validation.manager.core.db.IssueResolution; +import com.validation.manager.core.db.IssueType; +import com.validation.manager.core.db.RequirementType; +import com.validation.manager.core.db.VmSetting; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.IssueResolutionJpaController; +import com.validation.manager.core.db.controller.IssueTypeJpaController; +import com.validation.manager.core.db.controller.RequirementTypeJpaController; +import com.validation.manager.core.db.controller.exceptions.IllegalOrphanException; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.server.core.VMSettingServer; +import com.validation.manager.core.server.core.VMUserServer; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.util.Objects; +import java.util.logging.Level; +import java.util.logging.Logger; +import net.sourceforge.javydreamercsw.validation.manager.web.VMWindow; +import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; +import net.sourceforge.javydreamercsw.validation.manager.web.component.IssueResolutionComponent; +import net.sourceforge.javydreamercsw.validation.manager.web.component.IssueTypeComponent; +import net.sourceforge.javydreamercsw.validation.manager.web.component.RequirementTypeComponent; +import net.sourceforge.javydreamercsw.validation.manager.web.component.TranslationConverter; +import net.sourceforge.javydreamercsw.validation.manager.web.component.UserComponent; +import net.sourceforge.javydreamercsw.validation.manager.web.provider.AbstractProvider; +import org.openide.util.Lookup; +import org.openide.util.lookup.ServiceProvider; + +@ServiceProvider(service = IMainContentProvider.class, position = 4) +public class AdminScreenProvider extends AbstractProvider { + + private static final Logger LOG + = Logger.getLogger(IMainContentProvider.class.getSimpleName()); + private final TabSheet adminSheet = new TabSheet(); + private final String ISSUE_TYPE = "issue.type", + ISSUE_RESOLUTION = "issue.resolution", + REQUIREMENT_TYPE = "requirement.type", + DESC = "description", + DELETE_ERROR = "delete.error", + NAME = "name"; + + @Override + public Component getContent() { + VerticalLayout layout = new VerticalLayout(); + adminSheet.removeAllComponents(); + //Build left side + //Build setting tab + adminSheet.addTab(getSettingTab(), TRANSLATOR + .translate("general.settings")); + //Build email setting tab + adminSheet.addTab(getEmailSettingTab(), TRANSLATOR + .translate("general.email.settings")); + //Build user management tab + adminSheet.addTab(getUserManagementTab(), TRANSLATOR + .translate("menu.user")); + //Build configurable items management tab + adminSheet.addTab(getConfigurableTab(), TRANSLATOR + .translate("general.configuration")); + layout.addComponent(adminSheet); + layout.setId(getComponentCaption()); + return layout; + } + + @Override + public void update() { + adminSheet.removeAllComponents(); + adminSheet.addTab(getSettingTab(), TRANSLATOR + .translate("general.settings")); + //Build email setting tab + adminSheet.addTab(getEmailSettingTab(), TRANSLATOR + .translate("general.email.settings")); + //Build user management tab + adminSheet.addTab(getUserManagementTab(), TRANSLATOR + .translate("menu.user")); + //Build configurable items management tab + adminSheet.addTab(getConfigurableTab(), TRANSLATOR + .translate("general.configuration")); + super.update(); + } + + @Override + public String getComponentCaption() { + return "admin.tab.name"; + } + + @Override + public boolean shouldDisplay() { + return ValidationManagerUI.getInstance().getUser() != null + && ValidationManagerUI.getInstance() + .checkRight("system.configuration"); + } + + private Component displaySetting(VmSetting s) { + return displaySetting(s, false); + } + + private Component displaySetting(VmSetting s, boolean edit) { + Panel form = new Panel(TRANSLATOR + .translate("setting.detail")); + FormLayout layout = new FormLayout(); + form.setContent(layout); + form.addStyleName(ValoTheme.FORMLAYOUT_LIGHT); + BeanFieldGroup binder = new BeanFieldGroup(s.getClass()); + binder.setItemDataSource(s); + Field id = (TextField) binder.buildAndBind(TRANSLATOR + .translate("general.setting"), "setting"); + layout.addComponent(id); + Field bool = binder.buildAndBind(TRANSLATOR + .translate("bool.value"), "boolVal"); + bool.setSizeFull(); + layout.addComponent(bool); + Field integerVal = binder.buildAndBind(TRANSLATOR + .translate("int.value"), "intVal"); + integerVal.setSizeFull(); + layout.addComponent(integerVal); + Field longVal = binder.buildAndBind(TRANSLATOR + .translate("long.val"), "longVal"); + longVal.setSizeFull(); + layout.addComponent(longVal); + Field stringVal = binder.buildAndBind(TRANSLATOR + .translate("string.val"), "stringVal", + TextArea.class); + stringVal.setSizeFull(); + layout.addComponent(stringVal); + Button cancel = new Button(TRANSLATOR + .translate("general.cancel")); + cancel.addClickListener((Button.ClickEvent event) -> { + binder.discard(); + }); + //Editing existing one + Button update = new Button(TRANSLATOR + .translate("general.update")); + update.addClickListener((Button.ClickEvent event) -> { + try { + binder.commit(); + displaySetting(s); + } catch (FieldGroup.CommitException ex) { + LOG.log(Level.SEVERE, null, ex); + Notification.show(TRANSLATOR + .translate("general.error.record.update"), + ex.getLocalizedMessage(), + Notification.Type.ERROR_MESSAGE); + } + }); + boolean blocked = !s.getSetting().startsWith("version."); + if (blocked) { + HorizontalLayout hl = new HorizontalLayout(); + hl.addComponent(update); + hl.addComponent(cancel); + layout.addComponent(hl); + } + binder.setBuffered(true); + binder.setReadOnly(edit); + binder.bindMemberFields(form); + //The version settigns are not modifiable from the GUI + binder.setEnabled(blocked); + //Id is always blocked. + id.setEnabled(false); + form.setSizeFull(); + return form; + } + + private Component getEmailSettingTab() { + VerticalLayout s2 = new VerticalLayout(); + HorizontalSplitPanel split2 = new HorizontalSplitPanel(); + s2.addComponent(split2); + Tree sTree2 = new Tree(TRANSLATOR + .translate("general.email.settings")); + sTree2.addValueChangeListener((Property.ValueChangeEvent event) -> { + if (sTree2.getValue() instanceof VmSetting) { + VmSetting vmSetting = (VmSetting) sTree2.getValue(); + split2.setSecondComponent( + displaySetting(vmSetting, + !vmSetting.getSetting().equals("mail.enable"))); + } + }); + split2.setFirstComponent(sTree2); + VMSettingServer.getSettings().forEach(s -> { + if (s.getSetting().startsWith("mail")) { + sTree2.addItem(s); + sTree2.setChildrenAllowed(s, false); + sTree2.setItemCaption(s, TRANSLATOR + .translate(s.getSetting())); + } + }); + Button testEmail = new Button(TRANSLATOR + .translate("general.email.settings.test"), + listener -> { + //Show a window to test email settings + VMWindow w = new VMWindow(TRANSLATOR + .translate("general.email.settings.test")); + w.setModal(true); + VerticalLayout vl = new VerticalLayout(); + TextField to = new TextField(TRANSLATOR.translate("general.email.to")); + TextField from = new TextField(TRANSLATOR.translate("general.email.from")); + TextField subject = new TextField(TRANSLATOR.translate("general.email.subject")); + TextArea mess = new TextArea(TRANSLATOR.translate("general.email.message")); + mess.setSizeFull(); + TextArea output = new TextArea(TRANSLATOR.translate("general.output")); + output.setReadOnly(true); + output.setSizeFull(); + Button send = new Button(TRANSLATOR.translate("general.email.send"), + l -> { + try { + Lookup.getDefault().lookup(IEmailManager.class) + .sendEmail(to.getValue(), null, + from.getValue(), + subject.getValue(), + mess.getValue()); + output.setValue(TRANSLATOR.translate("general.email.settings.test.success")); + //Successful, update the enable setting. + VMSettingServer enable = new VMSettingServer("mail.enable"); + enable.setBoolVal(true); + enable.write2DB(); + } catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + StringWriter sw = new StringWriter(); + ex.printStackTrace(new PrintWriter(sw)); + output.setReadOnly(false); + output.setValue(sw.toString()); + output.setReadOnly(true); + } + }); + vl.addComponent(to); + vl.addComponent(from); + vl.addComponent(subject); + vl.addComponent(mess); + vl.addComponent(send); + vl.addComponent(output); + w.setContent(vl); + w.setHeight(75, Sizeable.Unit.PERCENTAGE); + w.setWidth(75, Sizeable.Unit.PERCENTAGE); + ValidationManagerUI.getInstance().addWindow(w); + }); + s2.addComponent(testEmail); + return s2; + } + + private Component getSettingTab() { + VerticalLayout sl = new VerticalLayout(); + HorizontalSplitPanel split1 = new HorizontalSplitPanel(); + sl.addComponent(split1); + Tree sTree = new Tree(TRANSLATOR + .translate("general.settings")); + split1.setFirstComponent(sTree); + sTree.addValueChangeListener((Property.ValueChangeEvent event) -> { + if (sTree.getValue() instanceof VmSetting) { + split1.setSecondComponent( + displaySetting((VmSetting) sTree.getValue())); + } + }); + VMSettingServer.getSettings().forEach(s -> { + if (!s.getSetting().startsWith("mail")) { + sTree.addItem(s); + sTree.setChildrenAllowed(s, false); + sTree.setItemCaption(s, TRANSLATOR + .translate(s.getSetting())); + } + }); + return sl; + } + + private Component getUserManagementTab() { + VerticalLayout vl = new VerticalLayout(); + HorizontalSplitPanel split = new HorizontalSplitPanel(); + vl.addComponent(split); + //Create left side + Tree users = new Tree(); + //Menu + VerticalLayout main = new VerticalLayout(); + main.addComponent(users); + HorizontalLayout hl = new HorizontalLayout(); + Button addUser = new Button(TRANSLATOR.translate("add.user")); + addUser.addClickListener(listener -> { + VmUser user = new VmUser(); + split.setSecondComponent(new UserComponent(user, true)); + }); + hl.addComponent(addUser); + main.addComponent(hl); + split.setFirstComponent(main); + VMUserServer.getVMUsers().forEach(user -> { + if (!Objects.equals(user.getId(), + ((VMUI) UI.getCurrent()).getUser().getId())) { + users.addItem(user.getEntity()); + users.setItemCaption(user.getEntity(), user.toString()); + users.setItemIcon(user.getEntity(), VaadinIcons.USER); + users.setChildrenAllowed(user.getEntity(), false); + } + }); + users.addValueChangeListener((Property.ValueChangeEvent event) -> { + VmUser user = (VmUser) users.getValue(); + split.setSecondComponent(new UserComponent(user, true)); + }); + vl.setSizeFull(); + return vl; + } + + private Component getConfigurableTab() { + VerticalLayout vl = new VerticalLayout(); + ComboBox options = new ComboBox(); + options.addItem(ISSUE_TYPE); + options.setItemCaption(ISSUE_TYPE, + TRANSLATOR.translate(ISSUE_TYPE)); + options.addItem(ISSUE_RESOLUTION); + options.setItemCaption(ISSUE_RESOLUTION, + TRANSLATOR.translate(ISSUE_RESOLUTION)); + options.addItem(REQUIREMENT_TYPE); + options.setItemCaption(REQUIREMENT_TYPE, + TRANSLATOR.translate(REQUIREMENT_TYPE)); + options.setTextInputAllowed(false); + options.addValueChangeListener((Property.ValueChangeEvent event) -> { + Component nextComp = null; + if (options.getValue() != null) { + switch ((String) options.getValue()) { + case ISSUE_TYPE: + nextComp = displayIssueTypes(); + break; + case ISSUE_RESOLUTION: + nextComp = displayIssueResolutions(); + break; + case REQUIREMENT_TYPE: + nextComp = displayRequirementTypes(); + break; + default: + //Do nothing + } + } + if (nextComp != null) { + vl.removeAllComponents(); + vl.addComponent(options); + vl.addComponent(nextComp); + } + }); + vl.addComponent(options); + vl.setSizeFull(); + return vl; + } + + private Component displayIssueTypes() { + VerticalLayout vl = new VerticalLayout(); + Grid grid = new Grid(TRANSLATOR.translate(ISSUE_TYPE)); + BeanItemContainer types + = new BeanItemContainer<>(IssueType.class); + types.addAll(new IssueTypeJpaController(DataBaseManager + .getEntityManagerFactory()) + .findIssueTypeEntities()); + grid.setContainerDataSource(types); + grid.setSelectionMode(SelectionMode.SINGLE); + grid.setColumns("typeName", DESC); + Grid.Column name = grid.getColumn("typeName"); + name.setHeaderCaption(TRANSLATOR.translate("general.name")); + name.setConverter(new TranslationConverter()); + Grid.Column desc = grid.getColumn(DESC); + desc.setHeaderCaption(TRANSLATOR.translate("general.description")); + desc.setConverter(new TranslationConverter()); + grid.setSizeFull(); + vl.addComponent(grid); + grid.setHeightMode(HeightMode.ROW); + grid.setHeightByRows(types.size() > 5 ? 5 : types.size()); + //Menu + HorizontalLayout hl = new HorizontalLayout(); + Button add = new Button(TRANSLATOR.translate("general.create")); + add.addClickListener(listener -> { + VMWindow w = new VMWindow(); + w.setContent(new IssueTypeComponent(new IssueType(), true)); + w.setModal(true); + ((VMUI) UI.getCurrent()).addWindow(w); + w.addCloseListener(l -> { + ((VMUI) UI.getCurrent()).updateScreen(); + }); + }); + hl.addComponent(add); + Button delete = new Button(TRANSLATOR.translate("general.delete")); + delete.setEnabled(false); + delete.addClickListener(listener -> { + IssueType selected = (IssueType) ((SingleSelectionModel) grid. + getSelectionModel()).getSelectedRow(); + if (selected != null && selected.getId() >= 1000) { + try { + new IssueTypeJpaController(DataBaseManager + .getEntityManagerFactory()) + .destroy(selected.getId()); + ((VMUI) UI.getCurrent()).updateScreen(); + } catch (IllegalOrphanException | NonexistentEntityException ex) { + LOG.log(Level.SEVERE, null, ex); + Notification.show(TRANSLATOR.translate(DELETE_ERROR), + TRANSLATOR.translate(DELETE_ERROR), + Notification.Type.ERROR_MESSAGE); + } + } + }); + hl.addComponent(delete); + vl.addComponent(hl); + grid.addSelectionListener(event -> { // Java 8 + // Get selection from the selection model + IssueType selected = (IssueType) ((SingleSelectionModel) grid. + getSelectionModel()).getSelectedRow(); + //Only delete custom ones. + delete.setEnabled(selected != null && selected.getId() >= 1000); + }); + return vl; + } + + private Component displayIssueResolutions() { + VerticalLayout vl = new VerticalLayout(); + Grid grid = new Grid(TRANSLATOR.translate(ISSUE_RESOLUTION)); + BeanItemContainer types + = new BeanItemContainer<>(IssueResolution.class); + types.addAll(new IssueResolutionJpaController(DataBaseManager + .getEntityManagerFactory()) + .findIssueResolutionEntities()); + grid.setContainerDataSource(types); + grid.setSelectionMode(SelectionMode.SINGLE); + grid.setColumns(NAME); + Grid.Column name = grid.getColumn(NAME); + name.setHeaderCaption(TRANSLATOR.translate("general.name")); + name.setConverter(new TranslationConverter()); + grid.setSizeFull(); + vl.addComponent(grid); + grid.setHeightMode(HeightMode.ROW); + grid.setHeightByRows(types.size() > 5 ? 5 : types.size()); + //Menu + HorizontalLayout hl = new HorizontalLayout(); + Button add = new Button(TRANSLATOR.translate("general.create")); + add.addClickListener(listener -> { + VMWindow w = new VMWindow(); + w.setContent(new IssueResolutionComponent(new IssueResolution(), true)); + w.setModal(true); + ((VMUI) UI.getCurrent()).addWindow(w); + w.addCloseListener(l -> { + ((VMUI) UI.getCurrent()).updateScreen(); + }); + }); + hl.addComponent(add); + Button delete = new Button(TRANSLATOR.translate("general.delete")); + delete.setEnabled(false); + delete.addClickListener(listener -> { + IssueResolution selected = (IssueResolution) ((SingleSelectionModel) grid. + getSelectionModel()).getSelectedRow(); + if (selected != null && selected.getId() >= 1000) { + try { + new IssueResolutionJpaController(DataBaseManager + .getEntityManagerFactory()) + .destroy(selected.getId()); + ((VMUI) UI.getCurrent()).updateScreen(); + } catch (IllegalOrphanException | NonexistentEntityException ex) { + LOG.log(Level.SEVERE, null, ex); + Notification.show(TRANSLATOR.translate(DELETE_ERROR), + TRANSLATOR.translate(DELETE_ERROR), + Notification.Type.ERROR_MESSAGE); + } + } + }); + hl.addComponent(delete); + vl.addComponent(hl); + grid.addSelectionListener(event -> { // Java 8 + // Get selection from the selection model + IssueResolution selected = (IssueResolution) ((SingleSelectionModel) grid. + getSelectionModel()).getSelectedRow(); + //Only delete custom ones. + delete.setEnabled(selected != null && selected.getId() >= 1000); + }); + return vl; + } + + private Component displayRequirementTypes() { + VerticalLayout vl = new VerticalLayout(); + Grid grid = new Grid(TRANSLATOR.translate(REQUIREMENT_TYPE)); + BeanItemContainer types + = new BeanItemContainer<>(RequirementType.class); + types.addAll(new RequirementTypeJpaController(DataBaseManager + .getEntityManagerFactory()) + .findRequirementTypeEntities()); + grid.setContainerDataSource(types); + grid.setSelectionMode(SelectionMode.SINGLE); + grid.setColumns(NAME, DESC); + Grid.Column name = grid.getColumn(NAME); + name.setHeaderCaption(TRANSLATOR.translate("general.name")); + name.setConverter(new TranslationConverter()); + Grid.Column desc = grid.getColumn(DESC); + desc.setHeaderCaption(TRANSLATOR.translate("general.description")); + desc.setConverter(new TranslationConverter()); + grid.setSizeFull(); + vl.addComponent(grid); + grid.setHeightMode(HeightMode.ROW); + grid.setHeightByRows(types.size() > 5 ? 5 : types.size()); + //Menu + HorizontalLayout hl = new HorizontalLayout(); + Button add = new Button(TRANSLATOR.translate("general.create")); + add.addClickListener(listener -> { + VMWindow w = new VMWindow(); + w.setContent(new RequirementTypeComponent(new RequirementType(), true)); + w.setModal(true); + ((VMUI) UI.getCurrent()).addWindow(w); + w.addCloseListener(l -> { + ((VMUI) UI.getCurrent()).updateScreen(); + }); + }); + hl.addComponent(add); + Button delete = new Button(TRANSLATOR.translate("general.delete")); + delete.setEnabled(false); + delete.addClickListener(listener -> { + RequirementType selected = (RequirementType) ((SingleSelectionModel) grid. + getSelectionModel()).getSelectedRow(); + if (selected != null && selected.getId() >= 1000) { + try { + new RequirementTypeJpaController(DataBaseManager + .getEntityManagerFactory()) + .destroy(selected.getId()); + ((VMUI) UI.getCurrent()).updateScreen(); + } catch (IllegalOrphanException | NonexistentEntityException ex) { + LOG.log(Level.SEVERE, null, ex); + Notification.show(TRANSLATOR.translate(DELETE_ERROR), + TRANSLATOR.translate(DELETE_ERROR), + Notification.Type.ERROR_MESSAGE); + } + } + }); + hl.addComponent(delete); + vl.addComponent(hl); + grid.addSelectionListener(event -> { // Java 8 + // Get selection from the selection model + RequirementType selected = (RequirementType) ((SingleSelectionModel) grid. + getSelectionModel()).getSelectedRow(); + //Only delete custom ones. + delete.setEnabled(selected != null && selected.getId() >= 1000); + }); + return vl; + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/ByteToStringConverter.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/ByteToStringConverter.java similarity index 93% rename from Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/ByteToStringConverter.java rename to Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/ByteToStringConverter.java index 6f43a582..f4893775 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/ByteToStringConverter.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/ByteToStringConverter.java @@ -13,54 +13,54 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web; - -import com.vaadin.data.util.converter.Converter; -import java.io.UnsupportedEncodingException; -import java.nio.charset.StandardCharsets; -import java.util.Locale; -import java.util.logging.Level; -import java.util.logging.Logger; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class ByteToStringConverter implements Converter { - - private static final Logger LOG - = Logger.getLogger(ByteToStringConverter.class.getSimpleName()); - - @Override - public byte[] convertToModel(String value, - Class targetType, Locale locale) - throws ConversionException { - try { - String result = value; - if (value == null) { - result = "null"; - } - return result.getBytes("UTF-8"); - } catch (UnsupportedEncodingException ex) { - LOG.log(Level.SEVERE, null, ex); - } - return null; - } - - @Override - public String convertToPresentation(byte[] value, - Class targetType, Locale locale) - throws ConversionException { - return value == null ? "null" : new String(value, StandardCharsets.UTF_8); - } - - @Override - public Class getModelType() { - return byte[].class; - } - - @Override - public Class getPresentationType() { - return String.class; - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.component; + +import com.vaadin.data.util.converter.Converter; +import java.io.UnsupportedEncodingException; +import java.nio.charset.StandardCharsets; +import java.util.Locale; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ByteToStringConverter implements Converter { + + private static final Logger LOG + = Logger.getLogger(ByteToStringConverter.class.getSimpleName()); + + @Override + public byte[] convertToModel(String value, + Class targetType, Locale locale) + throws ConversionException { + try { + String result = value; + if (value == null) { + result = "null"; + } + return result.getBytes("UTF-8"); + } catch (UnsupportedEncodingException ex) { + LOG.log(Level.SEVERE, null, ex); + } + return null; + } + + @Override + public String convertToPresentation(byte[] value, + Class targetType, Locale locale) + throws ConversionException { + return value == null ? "null" : new String(value, StandardCharsets.UTF_8); + } + + @Override + public Class getModelType() { + return byte[].class; + } + + @Override + public Class getPresentationType() { + return String.class; + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/IssueResolutionComponent.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/IssueResolutionComponent.java new file mode 100644 index 00000000..a35f0a15 --- /dev/null +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/IssueResolutionComponent.java @@ -0,0 +1,127 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package net.sourceforge.javydreamercsw.validation.manager.web.component; + +import com.vaadin.data.fieldgroup.BeanFieldGroup; +import com.vaadin.data.fieldgroup.FieldGroup; +import com.vaadin.ui.Button; +import com.vaadin.ui.Component; +import com.vaadin.ui.Field; +import com.vaadin.ui.FormLayout; +import com.vaadin.ui.HorizontalLayout; +import com.vaadin.ui.Panel; +import com.vaadin.ui.UI; +import com.vaadin.ui.themes.ValoTheme; +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.VMUI; +import com.validation.manager.core.api.internationalization.InternationalizationProvider; +import com.validation.manager.core.db.IssueResolution; +import com.validation.manager.core.db.controller.IssueResolutionJpaController; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.openide.util.Lookup; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class IssueResolutionComponent extends Panel { + + private final IssueResolution ir; + private boolean edit = false; + private static final InternationalizationProvider TRANSLATOR + = Lookup.getDefault().lookup(InternationalizationProvider.class); + private static final Logger LOG + = Logger.getLogger(IssueResolutionComponent.class.getSimpleName()); + + public IssueResolutionComponent(IssueResolution ir, boolean edit) { + setCaption(TRANSLATOR.translate("issue.resolution")); + this.ir = ir; + this.edit = edit; + init(); + } + + public IssueResolutionComponent(IssueResolution ir, Component content, + boolean edit) { + super(content); + setCaption(TRANSLATOR.translate("issue.resolution")); + this.ir = ir; + this.edit = edit; + init(); + } + + public IssueResolutionComponent(IssueResolution ir, String caption, + boolean edit) { + super(caption); + this.ir = ir; + this.edit = edit; + init(); + } + + public IssueResolutionComponent(IssueResolution ir, String caption, + Component content, boolean edit) { + super(caption, content); + this.ir = ir; + this.edit = edit; + init(); + } + + private void init() { + FormLayout layout = new FormLayout(); + setContent(layout); + addStyleName(ValoTheme.FORMLAYOUT_LIGHT); + BeanFieldGroup binder = new BeanFieldGroup(ir.getClass()); + binder.setItemDataSource(ir); + Field name = binder.buildAndBind(TRANSLATOR + .translate("general.name"), "name"); + layout.addComponent(name); + if (edit) { + Button update = new Button(ir.getId() == null + ? TRANSLATOR. + translate("general.create") + : TRANSLATOR. + translate("general.update")); + update.addClickListener((Button.ClickEvent event) -> { + IssueResolutionJpaController c + = new IssueResolutionJpaController(DataBaseManager. + getEntityManagerFactory()); + if (ir.getId() == null) { + ir.setName((String) name.getValue()); + c.create(ir); + } else { + try { + binder.commit(); + } catch (FieldGroup.CommitException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + }); + Button cancel = new Button(Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("general.cancel")); + cancel.addClickListener((Button.ClickEvent event) -> { + binder.discard(); + ((VMUI) UI.getCurrent()).updateScreen(); + }); + binder.setReadOnly(!edit); + binder.setBuffered(true); + HorizontalLayout hl = new HorizontalLayout(); + hl.addComponent(update); + hl.addComponent(cancel); + layout.addComponent(hl); + } + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/IssueTypeComponent.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/IssueTypeComponent.java new file mode 100644 index 00000000..1cf08b34 --- /dev/null +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/IssueTypeComponent.java @@ -0,0 +1,124 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package net.sourceforge.javydreamercsw.validation.manager.web.component; + +import com.vaadin.data.fieldgroup.BeanFieldGroup; +import com.vaadin.data.fieldgroup.FieldGroup; +import com.vaadin.ui.Button; +import com.vaadin.ui.Field; +import com.vaadin.ui.FormLayout; +import com.vaadin.ui.HorizontalLayout; +import com.vaadin.ui.Panel; +import com.vaadin.ui.UI; +import com.vaadin.ui.themes.ValoTheme; +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.VMUI; +import com.validation.manager.core.api.internationalization.InternationalizationProvider; +import com.validation.manager.core.db.IssueType; +import com.validation.manager.core.db.controller.IssueTypeJpaController; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.openide.util.Lookup; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class IssueTypeComponent extends Panel { + + private final IssueType it; + private boolean edit = false; + private static final InternationalizationProvider TRANSLATOR + = Lookup.getDefault().lookup(InternationalizationProvider.class); + private static final Logger LOG + = Logger.getLogger(IssueTypeComponent.class.getSimpleName()); + + public IssueTypeComponent(IssueType it, boolean edit) { + setCaption(TRANSLATOR.translate("issue.type")); + this.it = it; + this.edit = edit; + init(); + } + + public IssueTypeComponent(IssueType it, String caption, boolean edit) { + super(caption); + this.it = it; + this.edit = edit; + init(); + } + + public IssueTypeComponent(IssueType it) { + setCaption(TRANSLATOR.translate("issue.type")); + this.it = it; + init(); + } + + public IssueTypeComponent(IssueType it, String caption) { + super(caption); + this.it = it; + init(); + } + + private void init() { + FormLayout layout = new FormLayout(); + setContent(layout); + addStyleName(ValoTheme.FORMLAYOUT_LIGHT); + BeanFieldGroup binder = new BeanFieldGroup(it.getClass()); + binder.setItemDataSource(it); + Field name = binder.buildAndBind(TRANSLATOR + .translate("general.name"), "typeName"); + layout.addComponent(name); + Field desc = binder.buildAndBind(TRANSLATOR + .translate("general.description"), "description"); + layout.addComponent(desc); + if (edit) { + Button update = new Button(it.getId() == null + ? TRANSLATOR. + translate("general.create") + : TRANSLATOR. + translate("general.update")); + update.addClickListener((Button.ClickEvent event) -> { + IssueTypeJpaController c + = new IssueTypeJpaController(DataBaseManager. + getEntityManagerFactory()); + if (it.getId() == null) { + it.setDescription((String) desc.getValue()); + it.setTypeName((String) name.getValue()); + c.create(it); + } else { + try { + binder.commit(); + } catch (FieldGroup.CommitException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + }); + Button cancel = new Button(Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("general.cancel")); + cancel.addClickListener((Button.ClickEvent event) -> { + binder.discard(); + ((VMUI) UI.getCurrent()).updateScreen(); + }); + binder.setReadOnly(!edit); + binder.setBuffered(true); + HorizontalLayout hl = new HorizontalLayout(); + hl.addComponent(update); + hl.addComponent(cancel); + layout.addComponent(hl); + } + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/RequirementTypeComponent.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/RequirementTypeComponent.java new file mode 100644 index 00000000..99523d9e --- /dev/null +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/RequirementTypeComponent.java @@ -0,0 +1,131 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package net.sourceforge.javydreamercsw.validation.manager.web.component; + +import com.vaadin.data.fieldgroup.BeanFieldGroup; +import com.vaadin.data.fieldgroup.FieldGroup; +import com.vaadin.ui.Button; +import com.vaadin.ui.Component; +import com.vaadin.ui.Field; +import com.vaadin.ui.FormLayout; +import com.vaadin.ui.HorizontalLayout; +import com.vaadin.ui.Panel; +import com.vaadin.ui.UI; +import com.vaadin.ui.themes.ValoTheme; +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.VMUI; +import com.validation.manager.core.api.internationalization.InternationalizationProvider; +import com.validation.manager.core.db.RequirementType; +import com.validation.manager.core.db.controller.RequirementTypeJpaController; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.openide.util.Lookup; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class RequirementTypeComponent extends Panel { + + private final RequirementType rt; + private boolean edit = false; + private static final InternationalizationProvider TRANSLATOR + = Lookup.getDefault().lookup(InternationalizationProvider.class); + private static final Logger LOG + = Logger.getLogger(RequirementTypeComponent.class.getSimpleName()); + + public RequirementTypeComponent(RequirementType rt, boolean edit) { + setCaption(TRANSLATOR.translate("issue.resolution")); + this.rt = rt; + this.edit = edit; + init(); + } + + public RequirementTypeComponent(RequirementType rt, Component content, + boolean edit) { + super(content); + setCaption(TRANSLATOR.translate("issue.resolution")); + this.rt = rt; + this.edit = edit; + init(); + } + + public RequirementTypeComponent(RequirementType rt, String caption, + boolean edit) { + super(caption); + this.rt = rt; + this.edit = edit; + init(); + } + + public RequirementTypeComponent(RequirementType rt, String caption, + Component content, boolean edit) { + super(caption, content); + this.rt = rt; + this.edit = edit; + init(); + } + + private void init() { + FormLayout layout = new FormLayout(); + setContent(layout); + addStyleName(ValoTheme.FORMLAYOUT_LIGHT); + BeanFieldGroup binder = new BeanFieldGroup(rt.getClass()); + binder.setItemDataSource(rt); + Field name = binder.buildAndBind(TRANSLATOR + .translate("general.name"), "name"); + layout.addComponent(name); + Field desc = binder.buildAndBind(TRANSLATOR + .translate("general.description"), "description"); + layout.addComponent(desc); + if (edit) { + Button update = new Button(rt.getId() == null + ? TRANSLATOR. + translate("general.create") + : TRANSLATOR. + translate("general.update")); + update.addClickListener((Button.ClickEvent event) -> { + RequirementTypeJpaController c + = new RequirementTypeJpaController(DataBaseManager. + getEntityManagerFactory()); + if (rt.getId() == null) { + rt.setName((String) name.getValue()); + rt.setDescription((String) desc.getValue()); + c.create(rt); + } else { + try { + binder.commit(); + } catch (FieldGroup.CommitException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + }); + Button cancel = new Button(Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("general.cancel")); + cancel.addClickListener((Button.ClickEvent event) -> { + binder.discard(); + ((VMUI) UI.getCurrent()).updateScreen(); + }); + binder.setReadOnly(!edit); + binder.setBuffered(true); + HorizontalLayout hl = new HorizontalLayout(); + hl.addComponent(update); + hl.addComponent(cancel); + layout.addComponent(hl); + } + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/TranslationConverter.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/TranslationConverter.java new file mode 100644 index 00000000..f53b992f --- /dev/null +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/TranslationConverter.java @@ -0,0 +1,55 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package net.sourceforge.javydreamercsw.validation.manager.web.component; + +import com.vaadin.data.util.converter.Converter; +import com.validation.manager.core.api.internationalization.InternationalizationProvider; +import java.util.Locale; +import org.openide.util.Lookup; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class TranslationConverter implements Converter { + + private static final InternationalizationProvider TRANSLATOR + = Lookup.getDefault().lookup(InternationalizationProvider.class); + + @Override + public String convertToModel(String value, + Class targetType, Locale locale) + throws ConversionException { + return value; + } + + @Override + public String convertToPresentation(String value, + Class targetType, Locale locale) + throws ConversionException { + return TRANSLATOR.translate(value); + } + + @Override + public Class getModelType() { + return String.class; + } + + @Override + public Class getPresentationType() { + return String.class; + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/TreeTableCheckBox.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/TreeTableCheckBox.java similarity index 95% rename from Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/TreeTableCheckBox.java rename to Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/TreeTableCheckBox.java index db88c1a4..f1ceb69a 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/TreeTableCheckBox.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/TreeTableCheckBox.java @@ -13,90 +13,90 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web; - -import com.vaadin.data.Item; -import com.vaadin.sebastian.indeterminatecheckbox.IndeterminateCheckBox; -import com.vaadin.ui.TreeTable; -import java.util.Objects; -import java.util.logging.Level; -import java.util.logging.Logger; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public final class TreeTableCheckBox extends IndeterminateCheckBox { - - private final TreeTable tt; - private final static Logger LOG - = Logger.getLogger(TreeTableCheckBox.class.getSimpleName()); - private final Object objectId; - - public TreeTableCheckBox(TreeTable tt, Object objectId) { - this.tt = tt; - this.objectId = objectId; - initialize(); - } - - public TreeTableCheckBox(TreeTable tt, String caption, Object objectId) { - super(caption); - this.tt = tt; - this.objectId = objectId; - initialize(); - } - - public TreeTableCheckBox(TreeTable tt, String caption, - boolean initialState, Object objectId) { - super(caption, initialState); - this.tt = tt; - this.objectId = objectId; - initialize(); - } - - private void initialize() { - setUserCanToggleIndeterminate(false); - } - - @Override - protected void setInternalValue(Boolean value) { - if (tt != null - && value != null - && !Objects.equals(value, getState().value)) { - if (tt.hasChildren(getObjectId()) - && getState().value != null) { - //Switching from false to true. Select all children - tt.getChildren(getObjectId()).forEach((o) -> { - Item item = tt.getItem(o); - Object val = item.getItemProperty("Name").getValue(); - if (val instanceof TreeTableCheckBox) { - TreeTableCheckBox ttcb = (TreeTableCheckBox) val; - ttcb.setValue(value); - } - }); - } - Object parentId = tt.getParent(getObjectId()); - if (!value && parentId != null) { - //Switching from true to false. Mark parent as undeterminated - TreeTableCheckBox parent - = ((TreeTableCheckBox) tt.getItem(parentId) - .getItemProperty("Name").getValue()); - if (parent.getValue() != null && parent.getValue()) { - LOG.log(Level.INFO, "Setting {0} to undetermined.", - parentId); - parent.setValue(null); - } else { - LOG.info("Parent not selected!"); - } - } - } - super.setInternalValue(value); - } - - /** - * @return the objectId - */ - public Object getObjectId() { - return objectId; - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.component; + +import com.vaadin.data.Item; +import com.vaadin.sebastian.indeterminatecheckbox.IndeterminateCheckBox; +import com.vaadin.ui.TreeTable; +import java.util.Objects; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public final class TreeTableCheckBox extends IndeterminateCheckBox { + + private final TreeTable tt; + private final static Logger LOG + = Logger.getLogger(TreeTableCheckBox.class.getSimpleName()); + private final Object objectId; + + public TreeTableCheckBox(TreeTable tt, Object objectId) { + this.tt = tt; + this.objectId = objectId; + initialize(); + } + + public TreeTableCheckBox(TreeTable tt, String caption, Object objectId) { + super(caption); + this.tt = tt; + this.objectId = objectId; + initialize(); + } + + public TreeTableCheckBox(TreeTable tt, String caption, + boolean initialState, Object objectId) { + super(caption, initialState); + this.tt = tt; + this.objectId = objectId; + initialize(); + } + + private void initialize() { + setUserCanToggleIndeterminate(false); + } + + @Override + protected void setInternalValue(Boolean value) { + if (tt != null + && value != null + && !Objects.equals(value, getState().value)) { + if (tt.hasChildren(getObjectId()) + && getState().value != null) { + //Switching from false to true. Select all children + tt.getChildren(getObjectId()).forEach((o) -> { + Item item = tt.getItem(o); + Object val = item.getItemProperty("Name").getValue(); + if (val instanceof TreeTableCheckBox) { + TreeTableCheckBox ttcb = (TreeTableCheckBox) val; + ttcb.setValue(value); + } + }); + } + Object parentId = tt.getParent(getObjectId()); + if (!value && parentId != null) { + //Switching from true to false. Mark parent as undeterminated + TreeTableCheckBox parent + = ((TreeTableCheckBox) tt.getItem(parentId) + .getItemProperty("Name").getValue()); + if (parent.getValue() != null && parent.getValue()) { + LOG.log(Level.INFO, "Setting {0} to undetermined.", + parentId); + parent.setValue(null); + } else { + LOG.info("Parent not selected!"); + } + } + } + super.setInternalValue(value); + } + + /** + * @return the objectId + */ + public Object getObjectId() { + return objectId; + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserComponent.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserComponent.java new file mode 100644 index 00000000..6934e8df --- /dev/null +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserComponent.java @@ -0,0 +1,302 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package net.sourceforge.javydreamercsw.validation.manager.web.component; + +import com.vaadin.data.fieldgroup.BeanFieldGroup; +import com.vaadin.data.util.BeanItemContainer; +import com.vaadin.event.FieldEvents; +import com.vaadin.event.FieldEvents.TextChangeListener; +import com.vaadin.icons.VaadinIcons; +import com.vaadin.ui.Alignment; +import com.vaadin.ui.Button; +import com.vaadin.ui.ComboBox; +import com.vaadin.ui.Field; +import com.vaadin.ui.FormLayout; +import com.vaadin.ui.HorizontalLayout; +import com.vaadin.ui.Label; +import com.vaadin.ui.Notification; +import com.vaadin.ui.Panel; +import com.vaadin.ui.PasswordField; +import com.vaadin.ui.Table; +import com.vaadin.ui.TextField; +import com.vaadin.ui.TwinColSelect; +import com.vaadin.ui.UI; +import com.vaadin.ui.VerticalLayout; +import com.vaadin.ui.themes.ValoTheme; +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.VMException; +import com.validation.manager.core.VMUI; +import com.validation.manager.core.api.internationalization.InternationalizationProvider; +import com.validation.manager.core.db.Role; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.RoleJpaController; +import com.validation.manager.core.db.controller.UserStatusJpaController; +import com.validation.manager.core.server.core.VMUserServer; +import com.validation.manager.core.tool.MD5; +import de.steinwedel.messagebox.ButtonOption; +import de.steinwedel.messagebox.MessageBox; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import java.util.Set; +import java.util.logging.Level; +import java.util.logging.Logger; +import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; +import org.openide.util.Exceptions; +import org.openide.util.Lookup; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class UserComponent extends Panel { + + private final VmUser user; + private static final Logger LOG + = Logger.getLogger(UserComponent.class.getSimpleName()); + private static final InternationalizationProvider TRANSLATOR + = Lookup.getDefault().lookup(InternationalizationProvider.class); + private boolean edit = false; + + public UserComponent(VmUser user, boolean edit) { + this.user = user; + this.edit = edit; + init(); + } + + public UserComponent(VmUser user, String caption, boolean edit) { + super(caption); + this.user = user; + this.edit = edit; + init(); + } + + private void init() { + FormLayout layout = new FormLayout(); + setContent(layout); + addStyleName(ValoTheme.FORMLAYOUT_LIGHT); + BeanFieldGroup binder = new BeanFieldGroup(user.getClass()); + binder.setItemDataSource(user); + Field fn = binder.buildAndBind(TRANSLATOR. + translate("general.first.name"), + "firstName", TextField.class); + layout.addComponent(fn); + Field ln = binder.buildAndBind(TRANSLATOR. + translate("general.last.name"), + "lastName", TextField.class); + layout.addComponent(ln); + Field username = binder.buildAndBind(TRANSLATOR. + translate("general.username"), + "username", TextField.class); + layout.addComponent(username); + PasswordField pw = (PasswordField) binder.buildAndBind( + TRANSLATOR. + translate("general.password"), + "password", PasswordField.class); + PasswordChangeListener listener = new PasswordChangeListener(); + pw.addTextChangeListener(listener); + pw.setConverter(new UserPasswordConverter()); + layout.addComponent(pw); + Field email = binder.buildAndBind(TRANSLATOR. + translate("general.email"), + "email", TextField.class); + layout.addComponent(email); + ComboBox locale = new ComboBox(TRANSLATOR. + translate("general.locale")); + locale.setTextInputAllowed(false); + ValidationManagerUI.getAvailableLocales().forEach(l -> { + locale.addItem(l.toString()); + }); + if (user.getLocale() != null) { + locale.setValue(user.getLocale()); + } + binder.bind(locale, "locale"); + layout.addComponent(locale); + //Status + ComboBox status = new ComboBox(TRANSLATOR. + translate("general.status")); + new UserStatusJpaController(DataBaseManager.getEntityManagerFactory()) + .findUserStatusEntities().forEach(us -> { + status.addItem(us); + status.setItemCaption(us, + TRANSLATOR.translate(us.getStatus())); + }); + binder.bind(status, "userStatusId"); + status.setTextInputAllowed(false); + layout.addComponent(status); + //Roles + if (edit && ((VMUI) UI.getCurrent()).checkRight("system.configuration")) { + List list = new RoleJpaController(DataBaseManager + .getEntityManagerFactory()) + .findRoleEntities(); + Collections.sort(list, (Role r1, Role r2) + -> TRANSLATOR.translate(r1.getRoleName()) + .compareTo(TRANSLATOR + .translate(r2.getRoleName()))); + BeanItemContainer roleContainer + = new BeanItemContainer<>(Role.class, list); + TwinColSelect roles + = new TwinColSelect(TRANSLATOR.translate("general.role")); + roles.setContainerDataSource(roleContainer); + roles.setRows(5); + roles.setLeftColumnCaption(TRANSLATOR.translate("available.roles")); + roles.setRightColumnCaption(TRANSLATOR.translate("current.roles")); + list.forEach(r -> { + roles.setItemCaption(r, TRANSLATOR.translate(r.getDescription())); + }); + if (user.getRoleList() != null) { + user.getRoleList().forEach(r -> { + roles.select(r); + }); + } + roles.addValueChangeListener(event -> { + Set selected + = (Set) event.getProperty().getValue(); + if (user.getRoleList() == null) { + user.setRoleList(new ArrayList<>()); + } + user.getRoleList().clear(); + selected.forEach(r -> { + user.getRoleList().add(r); + }); + }); + layout.addComponent(roles); + } else { + if (!user.getRoleList().isEmpty()) { + Table roles = new Table(TRANSLATOR.translate("general.role")); + user.getRoleList().forEach(role -> { + roles.addItem(role); + roles.setItemCaption(role, + TRANSLATOR.translate(role.getRoleName())); + roles.setItemIcon(role, VaadinIcons.USER_STAR); + }); + layout.addComponent(roles); + } + } + Button update = new Button(user.getId() == null + ? TRANSLATOR. + translate("general.create") + : TRANSLATOR. + translate("general.update")); + update.addClickListener((Button.ClickEvent event) -> { + try { + VMUserServer us; + String password = (String) pw.getValue(); + if (user.getId() == null) { + us = new VMUserServer((String) username.getValue(), + password, + (String) fn.getValue(), + (String) ln.getValue(), + (String) email.getValue()); + } else { + us = new VMUserServer(user); + us.setFirstName((String) fn.getValue()); + us.setLastName((String) ln.getValue()); + us.setEmail((String) email.getValue()); + us.setUsername((String) username.getValue()); + } + us.setLocale((String) locale.getValue()); + if (listener.isChanged() + && !password.equals(user.getPassword())) { + //Different password. Prompt for confirmation + MessageBox mb = MessageBox.create(); + VerticalLayout vl = new VerticalLayout(); + Label l = new Label(TRANSLATOR. + translate("password.confirm.pw.message")); + vl.addComponent(l); + PasswordField np = new PasswordField(Lookup.getDefault() + .lookup(InternationalizationProvider.class) + .translate("general.password")); + vl.addComponent(np); + mb.asModal(true) + .withCaption(Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("password.confirm.pw")) + .withMessage(vl) + .withButtonAlignment(Alignment.MIDDLE_CENTER) + .withOkButton(() -> { + try { + if (password.equals(MD5.encrypt(np.getValue()))) { + us.setHashPassword(true); + us.setPassword(np.getValue()); + us.write2DB(); + Notification.show(TRANSLATOR. + translate("audit.user.account.password.change"), + Notification.Type.ASSISTIVE_NOTIFICATION); + ((VMUI) UI.getCurrent()).updateScreen(); + } else { + Notification.show(TRANSLATOR. + translate("password.does.not.match"), + Notification.Type.WARNING_MESSAGE); + } + mb.close(); + } catch (VMException ex) { + Exceptions.printStackTrace(ex); + } + }, ButtonOption.focus(), + ButtonOption.closeOnClick(false), + ButtonOption.icon(VaadinIcons.CHECK)) + .withCancelButton( + ButtonOption.icon(VaadinIcons.CLOSE) + ).getWindow().setIcon(ValidationManagerUI.SMALL_APP_ICON); + mb.open(); + } else { + us.write2DB(); + } + ((VMUI) UI.getCurrent()).getUser().update(); + ((VMUI) UI.getCurrent()).setLocale(new Locale(us.getLocale())); + ((VMUI) UI.getCurrent()).updateScreen(); + } catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + Notification.show(TRANSLATOR. + translate("general.error.record.update"), + ex.getLocalizedMessage(), + Notification.Type.ERROR_MESSAGE); + } + }); + Button cancel = new Button(Lookup.getDefault() + .lookup(InternationalizationProvider.class). + translate("general.cancel")); + cancel.addClickListener((Button.ClickEvent event) -> { + binder.discard(); + ((VMUI) UI.getCurrent()).updateScreen(); + }); + binder.setReadOnly(!edit); + binder.setBuffered(true); + HorizontalLayout hl = new HorizontalLayout(); + hl.addComponent(update); + hl.addComponent(cancel); + layout.addComponent(hl); + } + + private class PasswordChangeListener implements TextChangeListener { + + private boolean changed = false; + + @Override + public void textChange(FieldEvents.TextChangeEvent event) { + changed = true; + } + + /** + * @return the changed + */ + public boolean isChanged() { + return changed; + } + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/profile/UserPasswordConverter.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserPasswordConverter.java similarity index 83% rename from Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/profile/UserPasswordConverter.java rename to Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserPasswordConverter.java index 5e120135..724716c3 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/profile/UserPasswordConverter.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserPasswordConverter.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,48 +13,46 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web.profile; - -import com.vaadin.data.util.converter.Converter; -import com.validation.manager.core.tool.MD5; -import java.util.Locale; -import org.openide.util.Exceptions; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class UserPasswordConverter implements Converter { - - private String pw; - - @Override - public String convertToModel(String value, - Class targetType, Locale locale) - throws ConversionException { - pw = value; - return pw; - } - - @Override - public String convertToPresentation(String value, - Class targetType, Locale locale) - throws ConversionException { - try { - return MD5.encrypt(value); - } catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - return ""; - } - - @Override - public Class getModelType() { - return String.class; - } - - @Override - public Class getPresentationType() { - return String.class; - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.component; + +import com.vaadin.data.util.converter.Converter; +import com.validation.manager.core.VMException; +import com.validation.manager.core.tool.MD5; +import java.util.Locale; +import org.openide.util.Exceptions; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class UserPasswordConverter implements Converter { + + @Override + public String convertToModel(String value, + Class targetType, Locale locale) + throws ConversionException { + return value; + } + + @Override + public String convertToPresentation(String value, + Class targetType, Locale locale) + throws ConversionException { + try { + return value == null ? "" : MD5.encrypt(value); + } catch (VMException ex) { + Exceptions.printStackTrace(ex); + } + return ""; + } + + @Override + public Class getModelType() { + return String.class; + } + + @Override + public Class getPresentationType() { + return String.class; + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserStatusConverter.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserStatusConverter.java new file mode 100644 index 00000000..dbd4791f --- /dev/null +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserStatusConverter.java @@ -0,0 +1,67 @@ +/* + * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package net.sourceforge.javydreamercsw.validation.manager.web.component; + +import com.vaadin.data.util.converter.Converter; +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.api.internationalization.InternationalizationProvider; +import com.validation.manager.core.db.UserStatus; +import com.validation.manager.core.db.controller.UserStatusJpaController; +import java.util.Locale; +import org.openide.util.Lookup; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class UserStatusConverter implements Converter { + + private static final InternationalizationProvider TRANSLATOR + = Lookup.getDefault().lookup(InternationalizationProvider.class); + + @Override + public UserStatus convertToModel(String value, + Class targetType, + Locale locale) throws Converter.ConversionException { + UserStatus status = null; + for (UserStatus us + : new UserStatusJpaController(DataBaseManager + .getEntityManagerFactory()).findUserStatusEntities()) { + if (TRANSLATOR.translate(us.getStatus()).equals(value)) { + status = us; + break; + } + } + return status; + } + + @Override + public String convertToPresentation(UserStatus value, + Class targetType, + Locale locale) throws Converter.ConversionException { + return value == null ? "" : TRANSLATOR.translate(value.getStatus()); + } + + @Override + public Class getModelType() { + return UserStatus.class; + } + + @Override + public Class getPresentationType() { + return String.class; + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/UserToStringConverter.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserToStringConverter.java similarity index 92% rename from Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/UserToStringConverter.java rename to Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserToStringConverter.java index b6ddeed3..7dbf2bc5 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/UserToStringConverter.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/component/UserToStringConverter.java @@ -13,41 +13,41 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web; - -import com.vaadin.data.util.converter.Converter; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.server.core.VMUserServer; -import java.util.Locale; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class UserToStringConverter implements Converter { - - private VmUser user; - - @Override - public Class getModelType() { - return VmUser.class; - } - - @Override - public Class getPresentationType() { - return String.class; - } - - @Override - public VmUser convertToModel(String value, - Class targetType, Locale locale) throws ConversionException { - return user; - } - - @Override - public String convertToPresentation(VmUser value, - Class targetType, Locale locale) throws ConversionException { - user = value; - return new VMUserServer(value).toString(); - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.component; + +import com.vaadin.data.util.converter.Converter; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.server.core.VMUserServer; +import java.util.Locale; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class UserToStringConverter implements Converter { + + private VmUser user; + + @Override + public Class getModelType() { + return VmUser.class; + } + + @Override + public Class getPresentationType() { + return String.class; + } + + @Override + public VmUser convertToModel(String value, + Class targetType, Locale locale) throws ConversionException { + return user; + } + + @Override + public String convertToPresentation(VmUser value, + Class targetType, Locale locale) throws ConversionException { + user = value; + return new VMUserServer(value).toString(); + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/provider/DemoProvider.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/demo/DemoProvider.java similarity index 79% rename from Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/provider/DemoProvider.java rename to Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/demo/DemoProvider.java index 02d70eaa..49a3835e 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/provider/DemoProvider.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/demo/DemoProvider.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,91 +13,92 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web.provider; - -import com.vaadin.shared.ui.label.ContentMode; -import com.vaadin.ui.Component; -import com.vaadin.ui.Label; -import com.vaadin.ui.VerticalLayout; -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.IMainContentProvider; -import com.validation.manager.core.api.internationalization.InternationalizationProvider; -import com.validation.manager.core.db.controller.VmUserJpaController; -import com.validation.manager.core.tool.MD5; -import java.util.logging.Level; -import java.util.logging.Logger; -import org.openide.util.Lookup; -import org.openide.util.lookup.ServiceProvider; - -@ServiceProvider(service = IMainContentProvider.class) -public class DemoProvider extends AbstractProvider { - - private static final Logger LOG - = Logger.getLogger(DemoProvider.class.getSimpleName()); - private VerticalLayout layout; - - @Override - public Component getContent() { - if (layout == null) { - layout = new VerticalLayout(); - update(); - } - return layout; - } - - @Override - public void update() { - layout.removeAllComponents(); - VmUserJpaController controller - = new VmUserJpaController(DataBaseManager - .getEntityManagerFactory()); - layout.addComponent(new Label("

demo.tab.title

", - ContentMode.HTML)); - Label l = new Label(); - l.setId("demo.tab.message"); - layout.addComponent(l); - StringBuilder sb = new StringBuilder("
    "); - controller.findVmUserEntities().stream().filter((u) - -> (u.getId() < 1000)).forEachOrdered((u) -> { - try { - //Default accounts - if (u.getPassword() != null - && u.getPassword().equals(MD5 - .encrypt(u.getUsername()))) { - sb.append("
  • ") - .append("general.username") - .append(": ") - .append(u.getUsername()).append(", ") - .append("general.password") - .append(": ") - .append(u.getUsername()) - .append(" ") - .append("general.role") - .append(": ") - .append(Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate(u.getRoleList().get(0) - .getDescription())) - .append("
    • "); - } - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - }); - sb.append("
"); - layout.addComponent(new Label(sb.toString(), - ContentMode.HTML)); - layout.setId(getComponentCaption()); - super.update(); - } - - @Override - public String getComponentCaption() { - return "demo.tab.name"; - } - - @Override - public boolean shouldDisplay() { - return DataBaseManager.isDemo(); - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.demo; + +import com.vaadin.shared.ui.label.ContentMode; +import com.vaadin.ui.Component; +import com.vaadin.ui.Label; +import com.vaadin.ui.VerticalLayout; +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.IMainContentProvider; +import com.validation.manager.core.VMException; +import com.validation.manager.core.db.controller.VmUserJpaController; +import com.validation.manager.core.tool.MD5; +import java.util.logging.Level; +import java.util.logging.Logger; +import net.sourceforge.javydreamercsw.validation.manager.web.provider.AbstractProvider; +import org.openide.util.lookup.ServiceProvider; + +@ServiceProvider(service = IMainContentProvider.class) +public class DemoProvider extends AbstractProvider { + + private static final Logger LOG + = Logger.getLogger(DemoProvider.class.getSimpleName()); + private VerticalLayout layout; + + @Override + public Component getContent() { + if (layout == null) { + layout = new VerticalLayout(); + update(); + } + return layout; + } + + @Override + public void update() { + layout.removeAllComponents(); + VmUserJpaController controller + = new VmUserJpaController(DataBaseManager + .getEntityManagerFactory()); + layout.addComponent(new Label("

" + + TRANSLATOR.translate("demo.tab.title") + "

", + ContentMode.HTML)); + Label l = new Label(); + l.setId("demo.tab.message"); + layout.addComponent(l); + StringBuilder sb = new StringBuilder("
    "); + controller.findVmUserEntities().stream().filter((u) + -> (u.getId() < 1000)).forEachOrdered((u) -> { + try { + //Default accounts + if (u.getPassword() != null + && u.getPassword().equals(MD5 + .encrypt(u.getUsername()))) { + sb.append("
  • ") + .append(TRANSLATOR.translate("general.username")) + .append(": ") + .append(u.getUsername()) + .append(", ") + .append(TRANSLATOR.translate("general.password")) + .append(": ") + .append(u.getUsername()) + .append(" ") + .append(TRANSLATOR.translate("general.role")) + .append(": ") + .append(TRANSLATOR + .translate(u.getRoleList().get(0) + .getDescription())) + .append("
    • "); + } + } catch (VMException ex) { + LOG.log(Level.SEVERE, null, ex); + } + }); + sb.append("
"); + layout.addComponent(new Label(sb.toString(), + ContentMode.HTML)); + layout.setId(getComponentCaption()); + super.update(); + } + + @Override + public String getComponentCaption() { + return "demo.tab.name"; + } + + @Override + public boolean shouldDisplay() { + return DataBaseManager.isDemo(); + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/execution/ExecutionWizardStep.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/execution/ExecutionWizardStep.java index 7f672082..aa8fa979 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/execution/ExecutionWizardStep.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/execution/ExecutionWizardStep.java @@ -13,748 +13,748 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web.execution; - -import com.vaadin.data.fieldgroup.BeanFieldGroup; -import com.vaadin.event.FieldEvents.TextChangeEvent; -import com.vaadin.icons.VaadinIcons; -import com.vaadin.server.Resource; -import com.vaadin.server.Sizeable; -import com.vaadin.shared.ui.datefield.Resolution; -import com.vaadin.ui.Alignment; -import com.vaadin.ui.Button; -import com.vaadin.ui.ComboBox; -import com.vaadin.ui.Component; -import com.vaadin.ui.DateField; -import com.vaadin.ui.Field; -import com.vaadin.ui.FormLayout; -import com.vaadin.ui.HorizontalLayout; -import com.vaadin.ui.Label; -import com.vaadin.ui.Notification; -import com.vaadin.ui.Panel; -import com.vaadin.ui.TextArea; -import com.vaadin.ui.TextField; -import com.vaadin.ui.VerticalLayout; -import com.vaadin.ui.Window; -import com.vaadin.ui.themes.ValoTheme; -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.api.internationalization.InternationalizationProvider; -import com.validation.manager.core.db.AttachmentType; -import com.validation.manager.core.db.ExecutionResult; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.ExecutionStepHasAttachment; -import com.validation.manager.core.db.ExecutionStepHasIssue; -import com.validation.manager.core.db.ReviewResult; -import com.validation.manager.core.db.controller.ExecutionResultJpaController; -import com.validation.manager.core.db.controller.IssueTypeJpaController; -import com.validation.manager.core.db.controller.ReviewResultJpaController; -import com.validation.manager.core.server.core.AttachmentServer; -import com.validation.manager.core.server.core.AttachmentTypeServer; -import com.validation.manager.core.server.core.ExecutionResultServer; -import com.validation.manager.core.server.core.ExecutionStepServer; -import com.validation.manager.core.server.core.IssueServer; -import com.validation.manager.core.server.core.IssueTypeServer; -import com.validation.manager.core.server.core.ReviewResultServer; -import com.validation.manager.core.server.core.VMSettingServer; -import de.steinwedel.messagebox.ButtonOption; -import de.steinwedel.messagebox.ButtonType; -import de.steinwedel.messagebox.MessageBox; -import java.io.File; -import java.io.IOException; -import java.util.ArrayList; -import java.util.Date; -import java.util.Objects; -import java.util.logging.Level; -import java.util.logging.Logger; -import net.sourceforge.javydreamercsw.validation.manager.web.ByteToStringConverter; -import net.sourceforge.javydreamercsw.validation.manager.web.VMWindow; -import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; -import net.sourceforge.javydreamercsw.validation.manager.web.file.IFileDisplay; -import net.sourceforge.javydreamercsw.validation.manager.web.file.PDFDisplay; -import org.jodconverter.OfficeDocumentConverter; -import org.jodconverter.office.DefaultOfficeManagerBuilder; -import org.jodconverter.office.OfficeException; -import org.jodconverter.office.OfficeManager; -import org.openide.util.Lookup; -import org.vaadin.easyuploads.MultiFileUpload; -import org.vaadin.teemu.wizards.Wizard; -import org.vaadin.teemu.wizards.WizardStep; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class ExecutionWizardStep implements WizardStep { - - private final Wizard w; - private final ExecutionStepServer step; - private final ComboBox result = new ComboBox("general.result"); - private final ComboBox review = new ComboBox("quality.review"); - private final ComboBox issueType = new ComboBox("issue.type"); - private Button attach; - private Button bug; - private Button comment; - private DateField start; - private DateField end; - private DateField reviewDate; - private static final Logger LOG - = Logger.getLogger(ExecutionWizardStep.class.getSimpleName()); - private boolean reviewer = false; - - public ExecutionWizardStep(Wizard w, ExecutionStep step, - boolean reviewer) { - this.reviewer = reviewer; - this.w = w; - this.step = new ExecutionStepServer(step); - issueType.setSizeFull(); - issueType.setReadOnly(false); - issueType.setRequired(true); - issueType.setRequiredError("missing.type"); - IssueTypeJpaController it - = new IssueTypeJpaController(DataBaseManager - .getEntityManagerFactory()); - it.findIssueTypeEntities().forEach(type -> { - String item = Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate(type.getTypeName()); - issueType.addItem(type.getTypeName()); - issueType.setItemCaption(type.getTypeName(), item); - switch (type.getId()) { - case 1: - issueType.setItemIcon(type.getTypeName(), VaadinIcons.BUG); - break; - case 2: - issueType.setItemIcon(type.getTypeName(), VaadinIcons.EYE); - break; - case 3: - issueType.setItemIcon(type.getTypeName(), VaadinIcons.QUESTION); - break; - } - }); - result.setReadOnly(false); - result.setRequired(true); - result.setRequiredError("missing.result"); - result.setTextInputAllowed(false); - review.setReadOnly(false); - review.setRequired(true); - review.setRequiredError("missing.reviiew.result"); - review.setTextInputAllowed(false); - ReviewResultJpaController c2 - = new ReviewResultJpaController(DataBaseManager - .getEntityManagerFactory()); - c2.findReviewResultEntities().forEach(r -> { - String item = Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate(r.getReviewName()); - review.addItem(r.getReviewName()); - review.setItemCaption(r.getReviewName(), item); - Resource icon; - switch (r.getId()) { - case 1: - icon = VaadinIcons.CHECK; - break; - case 2: - icon = VaadinIcons.CLOSE; - break; - default: - icon = VaadinIcons.CLOCK; - break; - } - review.setItemIcon(r.getReviewName(), icon); - }); - ExecutionResultJpaController c - = new ExecutionResultJpaController(DataBaseManager - .getEntityManagerFactory()); - c.findExecutionResultEntities().forEach(r -> { - String item = Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate(r.getResultName()); - result.addItem(r.getResultName()); - result.setItemCaption(r.getResultName(), item); - Resource icon; - switch (r.getId()) { - case 1: - icon = VaadinIcons.CHECK; - break; - case 2: - icon = VaadinIcons.CLOSE; - break; - case 3: - icon = VaadinIcons.PAUSE; - break; - default: - icon = VaadinIcons.CLOCK; - break; - } - result.setItemIcon(r.getResultName(), icon); - }); - } - - @Override - public String getCaption() { - return getStep().getStep().getTestCase().getName() + " Step:" - + getStep().getStep().getStepSequence(); - } - - @Override - public Component getContent() { - getStep().update(); - Panel form = new Panel("step.detail"); - if (getStep().getExecutionStart() == null) { - //Set the start date. - getStep().setExecutionStart(new Date()); - } - FormLayout layout = new FormLayout(); - form.setContent(layout); - form.addStyleName(ValoTheme.FORMLAYOUT_LIGHT); - BeanFieldGroup binder = new BeanFieldGroup(getStep().getStep().getClass()); - binder.setItemDataSource(getStep().getStep()); - TextArea text = new TextArea("general.text"); - text.setConverter(new ByteToStringConverter()); - binder.bind(text, "text"); - text.setSizeFull(); - layout.addComponent(text); - Field notes = binder.buildAndBind("general.notes", "notes", - TextArea.class); - notes.setSizeFull(); - layout.addComponent(notes); - if (getStep().getExecutionStart() != null) { - start = new DateField("start.date"); - start.setResolution(Resolution.SECOND); - start.setDateFormat(VMSettingServer.getSetting("date.format") - .getStringVal()); - start.setValue(getStep().getExecutionStart()); - start.setReadOnly(true); - layout.addComponent(start); - } - if (getStep().getExecutionEnd() != null) { - end = new DateField(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("end.date")); - end.setDateFormat(VMSettingServer.getSetting("date.format") - .getStringVal()); - end.setResolution(Resolution.SECOND); - end.setValue(getStep().getExecutionEnd()); - end.setReadOnly(true); - layout.addComponent(end); - } - binder.setReadOnly(true); - //Space to record result - if (getStep().getResultId() != null) { - result.setValue(getStep().getResultId().getResultName()); - } - layout.addComponent(result); - if (reviewer) {//Space to record review - if (getStep().getReviewResultId() != null) { - review.setValue(getStep().getReviewResultId().getReviewName()); - } - layout.addComponent(review); - } - //Add Reviewer name - if (getStep().getReviewer() != null) { - TextField reviewerField = new TextField(Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate("general.reviewer")); - reviewerField.setValue(getStep().getReviewer().getFirstName() + " " - + getStep().getReviewer().getLastName()); - reviewerField.setReadOnly(true); - layout.addComponent(reviewerField); - } - if (getStep().getReviewDate() != null) { - reviewDate = new DateField(Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate("review.date")); - reviewDate.setDateFormat(VMSettingServer.getSetting("date.format") - .getStringVal()); - reviewDate.setResolution(Resolution.SECOND); - reviewDate.setValue(getStep().getReviewDate()); - reviewDate.setReadOnly(true); - layout.addComponent(reviewDate); - } - if (VMSettingServer.getSetting("show.expected.result").getBoolVal()) { - TextArea expectedResult = new TextArea("expected.result"); - expectedResult.setConverter(new ByteToStringConverter()); - binder.bind(expectedResult, "expectedResult"); - expectedResult.setSizeFull(); - layout.addComponent(expectedResult); - } - //Add the Attachments - HorizontalLayout attachments = new HorizontalLayout(); - attachments.setCaption("general.attachment"); - HorizontalLayout comments = new HorizontalLayout(); - comments.setCaption("general.comments"); - HorizontalLayout issues = new HorizontalLayout(); - issues.setCaption("general.issue"); - int commentCounter = 0; - int issueCounter = 0; - for (ExecutionStepHasIssue ei : getStep().getExecutionStepHasIssueList()) { - issueCounter++; - Button a = new Button("Issue #" + issueCounter); - a.setIcon(VaadinIcons.BUG); - a.addClickListener((Button.ClickEvent event) -> { - displayIssue(new IssueServer(ei.getIssue())); - }); - a.setEnabled(!step.getLocked()); - issues.addComponent(a); - } - for (ExecutionStepHasAttachment attachment - : getStep().getExecutionStepHasAttachmentList()) { - switch (attachment.getAttachment().getAttachmentType().getType()) { - case "comment": { - //Comments go in a different section - commentCounter++; - Button a = new Button("Comment #" + commentCounter); - a.setIcon(VaadinIcons.CLIPBOARD_TEXT); - a.addClickListener((Button.ClickEvent event) -> { - if (!step.getLocked()) { - //Prompt if user wants this removed - MessageBox mb = getDeletionPrompt(attachment); - mb.open(); - } else { - displayComment(new AttachmentServer(attachment - .getAttachment().getAttachmentPK())); - } - }); - a.setEnabled(!step.getLocked()); - comments.addComponent(a); - break; - } - default: { - Button a = new Button(attachment.getAttachment().getFileName()); - a.setEnabled(!step.getLocked()); - a.setIcon(VaadinIcons.PAPERCLIP); - a.addClickListener((Button.ClickEvent event) -> { - if (!step.getLocked()) { - //Prompt if user wants this removed - MessageBox mb = getDeletionPrompt(attachment); - mb.open(); - } else { - displayAttachment( - new AttachmentServer(attachment.getAttachment() - .getAttachmentPK())); - } - }); - attachments.addComponent(a); - break; - } - } - } - if (attachments.getComponentCount() > 0) { - layout.addComponent(attachments); - } - if (comments.getComponentCount() > 0) { - layout.addComponent(comments); - } - if (issues.getComponentCount() > 0) { - layout.addComponent(issues); - } - //Add the menu - HorizontalLayout hl = new HorizontalLayout(); - attach = new Button("add.attachment"); - attach.setIcon(VaadinIcons.PAPERCLIP); - attach.addClickListener((Button.ClickEvent event) -> { - //Show dialog to upload file. - Window dialog = new VMWindow("attach.file"); - VerticalLayout vl = new VerticalLayout(); - MultiFileUpload multiFileUpload = new MultiFileUpload() { - @Override - protected void handleFile(File file, String fileName, - String mimeType, long length) { - try { - LOG.log(Level.FINE, "Received file {1} at: {0}", - new Object[]{file.getAbsolutePath(), fileName}); - //Process the file - //Create the attachment - AttachmentServer a = new AttachmentServer(); - a.addFile(file, fileName); - //Overwrite the default file name set in addFile. It'll be a temporary file name - a.setFileName(fileName); - a.write2DB(); - //Now add it to this Execution Step - if (getStep().getExecutionStepHasAttachmentList() == null) { - getStep().setExecutionStepHasAttachmentList(new ArrayList<>()); - } - getStep().addAttachment(a); - getStep().write2DB(); - w.updateCurrentStep(); - } catch (Exception ex) { - LOG.log(Level.SEVERE, "Error creating attachment!", ex); - } - } - }; - multiFileUpload.setCaption("select.files.attach"); - vl.addComponent(multiFileUpload); - dialog.setContent(vl); - dialog.setHeight(25, Sizeable.Unit.PERCENTAGE); - dialog.setWidth(25, Sizeable.Unit.PERCENTAGE); - dialog.center(); - ValidationManagerUI.getInstance().addWindow(dialog); - }); - hl.addComponent(attach); - bug = new Button("create.issue"); - bug.setIcon(VaadinIcons.BUG); - bug.addClickListener((Button.ClickEvent event) -> { - displayIssue(new IssueServer()); - }); - hl.addComponent(bug); - comment = new Button("add.comment"); - comment.setIcon(VaadinIcons.CLIPBOARD_TEXT); - comment.addClickListener((Button.ClickEvent event) -> { - AttachmentServer as = new AttachmentServer(); - //Get comment type - AttachmentType type = AttachmentTypeServer - .getTypeForExtension("comment"); - as.setAttachmentType(type); - displayComment(as); - }); - hl.addComponent(comment); - step.update(); - attach.setEnabled(!step.getLocked()); - bug.setEnabled(!step.getLocked()); - comment.setEnabled(!step.getLocked()); - result.setEnabled(!step.getLocked()); - layout.addComponent(hl); - return layout; - } - - private void displayIssue(IssueServer is) { - Panel form = new Panel("general.issue"); - FormLayout layout = new FormLayout(); - form.setContent(layout); - if (is.getIssuePK() == null) { - //Set creation date - is.setCreationTime(new Date()); - } - BeanFieldGroup binder = new BeanFieldGroup(is.getClass()); - binder.setItemDataSource(is); - Field title = binder.buildAndBind("general.summary", "title", - TextField.class); - title.setSizeFull(); - layout.addComponent(title); - Field desc = binder.buildAndBind("general.description", "description", - TextArea.class); - desc.setSizeFull(); - layout.addComponent(desc); - DateField creation = (DateField) binder.buildAndBind("creation.time", - "creationTime", - DateField.class); - creation.setReadOnly(true); - creation.setDateFormat(VMSettingServer.getSetting("date.format") - .getStringVal()); - creation.setResolution(Resolution.SECOND); - layout.addComponent(creation); - //Add the result - layout.addComponent(issueType); - if (is.getIssueType() != null) { - issueType.setValue(is.getIssueType().getTypeName()); - } else { - //Set it as observation - issueType.setValue("observation.name"); - } - //Lock if being created - issueType.setReadOnly(is.getIssueType() == null); - MessageBox mb = MessageBox.create(); - mb.setData(is); - mb.asModal(true) - .withMessage(layout) - .withButtonAlignment(Alignment.MIDDLE_CENTER) - .withOkButton(() -> { - try { - //Create the attachment - IssueServer issue = (IssueServer) mb.getData(); - issue.setDescription(((TextArea) desc).getValue().trim()); - issue.setIssueType(IssueTypeServer.getType((String) issueType.getValue())); - issue.setCreationTime(creation.getValue()); - issue.setTitle((String) title.getValue()); - boolean toAdd = issue.getIssuePK() == null; - issue.write2DB(); - if (toAdd) { - //Now add it to this Execution Step - if (getStep().getExecutionStepHasIssueList() == null) { - getStep().setExecutionStepHasIssueList(new ArrayList<>()); - } - getStep().addIssue(issue, ValidationManagerUI - .getInstance().getUser()); - getStep().write2DB(); - } - w.updateCurrentStep(); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - }, ButtonOption.focus(), - ButtonOption.icon(VaadinIcons.CHECK), - ButtonOption.disable()) - .withCancelButton(ButtonOption.icon(VaadinIcons.CLOSE)); - mb.getWindow().setCaption("issue.detail"); - mb.getWindow().setIcon(ValidationManagerUI.SMALL_APP_ICON); - ((TextArea) desc).addTextChangeListener((TextChangeEvent event1) -> { - //Enable if there is a description change. - mb.getButton(ButtonType.OK) - .setEnabled(!step.getLocked() - && !event1.getText().trim().isEmpty()); - }); - ((TextField) title).addTextChangeListener((TextChangeEvent event1) -> { - //Enable if there is a title change. - mb.getButton(ButtonType.OK) - .setEnabled(!step.getLocked() - && !event1.getText().trim().isEmpty()); - }); - mb.open(); - } - - private void displayComment(AttachmentServer as) { - Panel form = new Panel("general.comment"); - FormLayout layout = new FormLayout(); - form.setContent(layout); - BeanFieldGroup binder = new BeanFieldGroup(as.getClass()); - binder.setItemDataSource(as); - Field desc = binder.buildAndBind("general.text", "textValue", - TextArea.class); - desc.setSizeFull(); - layout.addComponent(desc); - MessageBox mb = MessageBox.create(); - mb.setData(as); - mb.asModal(true) - .withMessage(desc) - .withButtonAlignment(Alignment.MIDDLE_CENTER) - .withOkButton(() -> { - try { - //Create the attachment - AttachmentServer a = (AttachmentServer) mb.getData(); - a.setTextValue(((TextArea) desc).getValue().trim()); - boolean toAdd = a.getAttachmentPK() == null; - a.write2DB(); - if (toAdd) { - //Now add it to this Execution Step - if (getStep().getExecutionStepHasAttachmentList() == null) { - getStep().setExecutionStepHasAttachmentList(new ArrayList<>()); - } - getStep().addAttachment(a); - getStep().write2DB(); - } - w.updateCurrentStep(); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - }, ButtonOption.focus(), - ButtonOption.icon(VaadinIcons.CHECK), - ButtonOption.disable()) - .withCancelButton(ButtonOption.icon(VaadinIcons.CLOSE)); - mb.getWindow().setCaption("enter.comment"); - mb.getWindow().setIcon(ValidationManagerUI.SMALL_APP_ICON); - ((TextArea) desc).addTextChangeListener((TextChangeEvent event1) -> { - //Enable only when there is a comment. - mb.getButton(ButtonType.OK) - .setEnabled(!step.getLocked() - && !event1.getText().trim().isEmpty()); - }); - mb.open(); - } - - @Override - public boolean onAdvance() { - //Can only proceed after the current step is executed and documented. - String answer = ((String) result.getValue()); - String answer2 = ((String) review.getValue()); - if (answer == null) { - Notification.show("unable.to.proceed", - result.getRequiredError(), - Notification.Type.WARNING_MESSAGE); - } else if (reviewer && answer2 == null) { - Notification.show("unable.to.proceed", - review.getRequiredError(), - Notification.Type.WARNING_MESSAGE); - } else { - try { - //Save the result - ExecutionResult newResult = ExecutionResultServer - .getResult(answer); - ReviewResult newReview = ReviewResultServer.getReview(answer2); - getStep().setExecutionStart(start.getValue()); - if (getStep().getResultId() == null - || !Objects.equals(step.getResultId().getId(), - newResult.getId())) { - getStep().setResultId(newResult); - //Set end date to null to reflect update - getStep().setExecutionEnd(null); - } - if (getStep().getReviewResultId() == null - || !Objects.equals(step.getReviewResultId().getId(), - newReview.getId())) { - getStep().setReviewResultId(newReview); - //Set end date to null to reflect update - getStep().setReviewer(ValidationManagerUI.getInstance().getUser()); - } - if (getStep().getExecutionEnd() == null) { - getStep().setExecutionEnd(new Date()); - } - if (reviewer && getStep().getReviewDate() == null) { - getStep().setReviewDate(new Date()); - } - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - boolean validAnswer = result.getValue() != null - && !((String) result.getValue()).trim().isEmpty(); - boolean validReview = review.getValue() != null - && !((String) review.getValue()).trim().isEmpty(); - return reviewer ? validReview && validAnswer : validAnswer; - } - - @Override - public boolean onBack() { - return getStep().getStep().getStepSequence() > 1; - } - - /** - * @return the step - */ - public ExecutionStepServer getStep() { - return step; - } - - public static boolean getPDFRendering(File source, File dest) - throws IllegalStateException { - OfficeManager officeManager = null; - try { - File home = new File(VMSettingServer.getSetting("openoffice.home") - .getStringVal()); - int port = VMSettingServer - .getSetting("openoffice.port").getIntVal(); - if (!home.isDirectory() || !home.exists()) { - LOG.log(Level.WARNING, - "Unable to find OpenOffice and/or LibreOffice " - + "installation at: {0}", home); - Notification.show("unable.to.render.pdf.title", - "unable.to.render.pdf.message", - Notification.Type.ERROR_MESSAGE); - return false; - } - if (port <= 0) { - LOG.log(Level.WARNING, - "Unable to find OpenOffice and/or LibreOffice " - + "installation at port: {0}", port); - Notification.show("unable.to.render.pdf.title", - "unable.to.render.pdf.port", - Notification.Type.ERROR_MESSAGE); - return false; - } - // Connect to an OpenOffice.org instance running on available port - try { - officeManager = new DefaultOfficeManagerBuilder() - .setPortNumber(port) - .setOfficeHome(home) - .build(); - officeManager.start(); - - OfficeDocumentConverter converter - = new OfficeDocumentConverter(officeManager); - converter.convert(source, dest); - // close the connection - officeManager.stop(); - return true; - } catch (IllegalStateException ise) { - //Looks like OpenOffice or LibreOffice is not installed - LOG.log(Level.WARNING, - "Unable to find OpenOffice and/or LibreOffice " - + "installation.", ise); - } - } catch (OfficeException e) { - if (officeManager != null) { - try { - officeManager.stop(); - } catch (OfficeException ex) { - LOG.log(Level.SEVERE, null, ex); - } - } - LOG.log(Level.SEVERE, null, e); - } - return false; - } - - private void displayAttachment(AttachmentServer attachment) { - String name = attachment.getFileName(); - byte[] bytes = attachment.getFile(); - boolean ableToDisplay = false; - try { - for (IFileDisplay fd : Lookup.getDefault() - .lookupAll(IFileDisplay.class)) { - if (fd.supportFile(new File(name))) { - ValidationManagerUI.getInstance() - .addWindow(fd.getViewer(fd.loadFile(name, - bytes))); - ableToDisplay = true; - break; - } - } - if (!ableToDisplay) { - //Convert file to pfd - PDFDisplay pdf = new PDFDisplay(); - File source = pdf.loadFile(name, bytes); - File dest = new File(System.getProperty("java.io.tmpdir") - + System.getProperty("file.separator") - + name.substring(0, name.lastIndexOf(".")) - + ".pdf"); - getPDFRendering(source, dest); - if (dest.exists()) { - ValidationManagerUI.getInstance().addWindow(pdf.getViewer(dest)); - ableToDisplay = true; - } - } - } catch (IOException ex) { - LOG.log(Level.SEVERE, - "Error loading attachment file: " - + name, ex); - } - if (!ableToDisplay) { - Notification.show("unable.to.render.pdf.title", - "unable.to.render.pdf.message", - Notification.Type.ERROR_MESSAGE); - } - } - - private MessageBox getDeletionPrompt(Object data) { - MessageBox mb = MessageBox.createQuestion(); - mb.setData(data); - mb.asModal(true) - .withMessage(new Label("remove.item.title")) - .withButtonAlignment(Alignment.MIDDLE_CENTER) - .withYesButton(() -> { - try { - if (mb.getData() instanceof ExecutionStepHasAttachment) { - getStep().removeAttachment(new AttachmentServer( - ((ExecutionStepHasAttachment) mb.getData()) - .getAttachment().getAttachmentPK())); - } - if (mb.getData() instanceof ExecutionStepHasIssue) { - getStep().removeIssue(new IssueServer( - ((ExecutionStepHasIssue) mb.getData()) - .getIssue())); - } - getStep().write2DB(); - getStep().update(); - w.updateCurrentStep(); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - }, ButtonOption.focus(), - ButtonOption.icon(VaadinIcons.CHECK)) - .withNoButton(() -> { - if (mb.getData() instanceof ExecutionStepHasAttachment) { - ExecutionStepHasAttachment esha = (ExecutionStepHasAttachment) mb.getData(); - if (esha.getAttachment().getAttachmentType().getType().equals("comment")) { - displayComment(new AttachmentServer(esha - .getAttachment().getAttachmentPK())); - } else { - displayAttachment(new AttachmentServer(esha - .getAttachment().getAttachmentPK())); - } - } - if (mb.getData() instanceof ExecutionStepHasIssue) { - ExecutionStepHasIssue eshi = (ExecutionStepHasIssue) mb.getData(); - displayIssue(new IssueServer(eshi.getIssue())); - } - }, - ButtonOption.icon(VaadinIcons.CLOSE)); - mb.getWindow().setCaption("issue.details"); - mb.getWindow().setIcon(ValidationManagerUI.SMALL_APP_ICON); - return mb; - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.execution; + +import com.vaadin.data.fieldgroup.BeanFieldGroup; +import com.vaadin.event.FieldEvents.TextChangeEvent; +import com.vaadin.icons.VaadinIcons; +import com.vaadin.server.Resource; +import com.vaadin.server.Sizeable; +import com.vaadin.shared.ui.datefield.Resolution; +import com.vaadin.ui.Alignment; +import com.vaadin.ui.Button; +import com.vaadin.ui.ComboBox; +import com.vaadin.ui.Component; +import com.vaadin.ui.DateField; +import com.vaadin.ui.Field; +import com.vaadin.ui.FormLayout; +import com.vaadin.ui.HorizontalLayout; +import com.vaadin.ui.Label; +import com.vaadin.ui.Notification; +import com.vaadin.ui.Panel; +import com.vaadin.ui.TextArea; +import com.vaadin.ui.TextField; +import com.vaadin.ui.VerticalLayout; +import com.vaadin.ui.Window; +import com.vaadin.ui.themes.ValoTheme; +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.api.internationalization.InternationalizationProvider; +import com.validation.manager.core.db.AttachmentType; +import com.validation.manager.core.db.ExecutionResult; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.ExecutionStepHasAttachment; +import com.validation.manager.core.db.ExecutionStepHasIssue; +import com.validation.manager.core.db.ReviewResult; +import com.validation.manager.core.db.controller.ExecutionResultJpaController; +import com.validation.manager.core.db.controller.IssueTypeJpaController; +import com.validation.manager.core.db.controller.ReviewResultJpaController; +import com.validation.manager.core.server.core.AttachmentServer; +import com.validation.manager.core.server.core.AttachmentTypeServer; +import com.validation.manager.core.server.core.ExecutionResultServer; +import com.validation.manager.core.server.core.ExecutionStepServer; +import com.validation.manager.core.server.core.IssueServer; +import com.validation.manager.core.server.core.IssueTypeServer; +import com.validation.manager.core.server.core.ReviewResultServer; +import com.validation.manager.core.server.core.VMSettingServer; +import de.steinwedel.messagebox.ButtonOption; +import de.steinwedel.messagebox.ButtonType; +import de.steinwedel.messagebox.MessageBox; +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Date; +import java.util.Objects; +import java.util.logging.Level; +import java.util.logging.Logger; +import net.sourceforge.javydreamercsw.validation.manager.web.component.ByteToStringConverter; +import net.sourceforge.javydreamercsw.validation.manager.web.VMWindow; +import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; +import net.sourceforge.javydreamercsw.validation.manager.web.file.IFileDisplay; +import net.sourceforge.javydreamercsw.validation.manager.web.file.PDFDisplay; +import org.jodconverter.OfficeDocumentConverter; +import org.jodconverter.office.DefaultOfficeManagerBuilder; +import org.jodconverter.office.OfficeException; +import org.jodconverter.office.OfficeManager; +import org.openide.util.Lookup; +import org.vaadin.easyuploads.MultiFileUpload; +import org.vaadin.teemu.wizards.Wizard; +import org.vaadin.teemu.wizards.WizardStep; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class ExecutionWizardStep implements WizardStep { + + private final Wizard w; + private final ExecutionStepServer step; + private final ComboBox result = new ComboBox("general.result"); + private final ComboBox review = new ComboBox("quality.review"); + private final ComboBox issueType = new ComboBox("issue.type"); + private Button attach; + private Button bug; + private Button comment; + private DateField start; + private DateField end; + private DateField reviewDate; + private static final Logger LOG + = Logger.getLogger(ExecutionWizardStep.class.getSimpleName()); + private boolean reviewer = false; + + public ExecutionWizardStep(Wizard w, ExecutionStep step, + boolean reviewer) { + this.reviewer = reviewer; + this.w = w; + this.step = new ExecutionStepServer(step); + issueType.setSizeFull(); + issueType.setReadOnly(false); + issueType.setRequired(true); + issueType.setRequiredError("missing.type"); + IssueTypeJpaController it + = new IssueTypeJpaController(DataBaseManager + .getEntityManagerFactory()); + it.findIssueTypeEntities().forEach(type -> { + String item = Lookup.getDefault().lookup(InternationalizationProvider.class) + .translate(type.getTypeName()); + issueType.addItem(type.getTypeName()); + issueType.setItemCaption(type.getTypeName(), item); + switch (type.getId()) { + case 1: + issueType.setItemIcon(type.getTypeName(), VaadinIcons.BUG); + break; + case 2: + issueType.setItemIcon(type.getTypeName(), VaadinIcons.EYE); + break; + case 3: + issueType.setItemIcon(type.getTypeName(), VaadinIcons.QUESTION); + break; + } + }); + result.setReadOnly(false); + result.setRequired(true); + result.setRequiredError("missing.result"); + result.setTextInputAllowed(false); + review.setReadOnly(false); + review.setRequired(true); + review.setRequiredError("missing.reviiew.result"); + review.setTextInputAllowed(false); + ReviewResultJpaController c2 + = new ReviewResultJpaController(DataBaseManager + .getEntityManagerFactory()); + c2.findReviewResultEntities().forEach(r -> { + String item = Lookup.getDefault().lookup(InternationalizationProvider.class) + .translate(r.getReviewName()); + review.addItem(r.getReviewName()); + review.setItemCaption(r.getReviewName(), item); + Resource icon; + switch (r.getId()) { + case 1: + icon = VaadinIcons.CHECK; + break; + case 2: + icon = VaadinIcons.CLOSE; + break; + default: + icon = VaadinIcons.CLOCK; + break; + } + review.setItemIcon(r.getReviewName(), icon); + }); + ExecutionResultJpaController c + = new ExecutionResultJpaController(DataBaseManager + .getEntityManagerFactory()); + c.findExecutionResultEntities().forEach(r -> { + String item = Lookup.getDefault().lookup(InternationalizationProvider.class) + .translate(r.getResultName()); + result.addItem(r.getResultName()); + result.setItemCaption(r.getResultName(), item); + Resource icon; + switch (r.getId()) { + case 1: + icon = VaadinIcons.CHECK; + break; + case 2: + icon = VaadinIcons.CLOSE; + break; + case 3: + icon = VaadinIcons.PAUSE; + break; + default: + icon = VaadinIcons.CLOCK; + break; + } + result.setItemIcon(r.getResultName(), icon); + }); + } + + @Override + public String getCaption() { + return getStep().getStep().getTestCase().getName() + " Step:" + + getStep().getStep().getStepSequence(); + } + + @Override + public Component getContent() { + getStep().update(); + Panel form = new Panel("step.detail"); + if (getStep().getExecutionStart() == null) { + //Set the start date. + getStep().setExecutionStart(new Date()); + } + FormLayout layout = new FormLayout(); + form.setContent(layout); + form.addStyleName(ValoTheme.FORMLAYOUT_LIGHT); + BeanFieldGroup binder = new BeanFieldGroup(getStep().getStep().getClass()); + binder.setItemDataSource(getStep().getStep()); + TextArea text = new TextArea("general.text"); + text.setConverter(new ByteToStringConverter()); + binder.bind(text, "text"); + text.setSizeFull(); + layout.addComponent(text); + Field notes = binder.buildAndBind("general.notes", "notes", + TextArea.class); + notes.setSizeFull(); + layout.addComponent(notes); + if (getStep().getExecutionStart() != null) { + start = new DateField("start.date"); + start.setResolution(Resolution.SECOND); + start.setDateFormat(VMSettingServer.getSetting("date.format") + .getStringVal()); + start.setValue(getStep().getExecutionStart()); + start.setReadOnly(true); + layout.addComponent(start); + } + if (getStep().getExecutionEnd() != null) { + end = new DateField(Lookup.getDefault().lookup(InternationalizationProvider.class) + .translate("end.date")); + end.setDateFormat(VMSettingServer.getSetting("date.format") + .getStringVal()); + end.setResolution(Resolution.SECOND); + end.setValue(getStep().getExecutionEnd()); + end.setReadOnly(true); + layout.addComponent(end); + } + binder.setReadOnly(true); + //Space to record result + if (getStep().getResultId() != null) { + result.setValue(getStep().getResultId().getResultName()); + } + layout.addComponent(result); + if (reviewer) {//Space to record review + if (getStep().getReviewResultId() != null) { + review.setValue(getStep().getReviewResultId().getReviewName()); + } + layout.addComponent(review); + } + //Add Reviewer name + if (getStep().getReviewer() != null) { + TextField reviewerField = new TextField(Lookup.getDefault() + .lookup(InternationalizationProvider.class) + .translate("general.reviewer")); + reviewerField.setValue(getStep().getReviewer().getFirstName() + " " + + getStep().getReviewer().getLastName()); + reviewerField.setReadOnly(true); + layout.addComponent(reviewerField); + } + if (getStep().getReviewDate() != null) { + reviewDate = new DateField(Lookup.getDefault() + .lookup(InternationalizationProvider.class) + .translate("review.date")); + reviewDate.setDateFormat(VMSettingServer.getSetting("date.format") + .getStringVal()); + reviewDate.setResolution(Resolution.SECOND); + reviewDate.setValue(getStep().getReviewDate()); + reviewDate.setReadOnly(true); + layout.addComponent(reviewDate); + } + if (VMSettingServer.getSetting("show.expected.result").getBoolVal()) { + TextArea expectedResult = new TextArea("expected.result"); + expectedResult.setConverter(new ByteToStringConverter()); + binder.bind(expectedResult, "expectedResult"); + expectedResult.setSizeFull(); + layout.addComponent(expectedResult); + } + //Add the Attachments + HorizontalLayout attachments = new HorizontalLayout(); + attachments.setCaption("general.attachment"); + HorizontalLayout comments = new HorizontalLayout(); + comments.setCaption("general.comments"); + HorizontalLayout issues = new HorizontalLayout(); + issues.setCaption("general.issue"); + int commentCounter = 0; + int issueCounter = 0; + for (ExecutionStepHasIssue ei : getStep().getExecutionStepHasIssueList()) { + issueCounter++; + Button a = new Button("Issue #" + issueCounter); + a.setIcon(VaadinIcons.BUG); + a.addClickListener((Button.ClickEvent event) -> { + displayIssue(new IssueServer(ei.getIssue())); + }); + a.setEnabled(!step.getLocked()); + issues.addComponent(a); + } + for (ExecutionStepHasAttachment attachment + : getStep().getExecutionStepHasAttachmentList()) { + switch (attachment.getAttachment().getAttachmentType().getType()) { + case "comment": { + //Comments go in a different section + commentCounter++; + Button a = new Button("Comment #" + commentCounter); + a.setIcon(VaadinIcons.CLIPBOARD_TEXT); + a.addClickListener((Button.ClickEvent event) -> { + if (!step.getLocked()) { + //Prompt if user wants this removed + MessageBox mb = getDeletionPrompt(attachment); + mb.open(); + } else { + displayComment(new AttachmentServer(attachment + .getAttachment().getAttachmentPK())); + } + }); + a.setEnabled(!step.getLocked()); + comments.addComponent(a); + break; + } + default: { + Button a = new Button(attachment.getAttachment().getFileName()); + a.setEnabled(!step.getLocked()); + a.setIcon(VaadinIcons.PAPERCLIP); + a.addClickListener((Button.ClickEvent event) -> { + if (!step.getLocked()) { + //Prompt if user wants this removed + MessageBox mb = getDeletionPrompt(attachment); + mb.open(); + } else { + displayAttachment( + new AttachmentServer(attachment.getAttachment() + .getAttachmentPK())); + } + }); + attachments.addComponent(a); + break; + } + } + } + if (attachments.getComponentCount() > 0) { + layout.addComponent(attachments); + } + if (comments.getComponentCount() > 0) { + layout.addComponent(comments); + } + if (issues.getComponentCount() > 0) { + layout.addComponent(issues); + } + //Add the menu + HorizontalLayout hl = new HorizontalLayout(); + attach = new Button("add.attachment"); + attach.setIcon(VaadinIcons.PAPERCLIP); + attach.addClickListener((Button.ClickEvent event) -> { + //Show dialog to upload file. + Window dialog = new VMWindow("attach.file"); + VerticalLayout vl = new VerticalLayout(); + MultiFileUpload multiFileUpload = new MultiFileUpload() { + @Override + protected void handleFile(File file, String fileName, + String mimeType, long length) { + try { + LOG.log(Level.FINE, "Received file {1} at: {0}", + new Object[]{file.getAbsolutePath(), fileName}); + //Process the file + //Create the attachment + AttachmentServer a = new AttachmentServer(); + a.addFile(file, fileName); + //Overwrite the default file name set in addFile. It'll be a temporary file name + a.setFileName(fileName); + a.write2DB(); + //Now add it to this Execution Step + if (getStep().getExecutionStepHasAttachmentList() == null) { + getStep().setExecutionStepHasAttachmentList(new ArrayList<>()); + } + getStep().addAttachment(a); + getStep().write2DB(); + w.updateCurrentStep(); + } catch (Exception ex) { + LOG.log(Level.SEVERE, "Error creating attachment!", ex); + } + } + }; + multiFileUpload.setCaption("select.files.attach"); + vl.addComponent(multiFileUpload); + dialog.setContent(vl); + dialog.setHeight(25, Sizeable.Unit.PERCENTAGE); + dialog.setWidth(25, Sizeable.Unit.PERCENTAGE); + dialog.center(); + ValidationManagerUI.getInstance().addWindow(dialog); + }); + hl.addComponent(attach); + bug = new Button("create.issue"); + bug.setIcon(VaadinIcons.BUG); + bug.addClickListener((Button.ClickEvent event) -> { + displayIssue(new IssueServer()); + }); + hl.addComponent(bug); + comment = new Button("add.comment"); + comment.setIcon(VaadinIcons.CLIPBOARD_TEXT); + comment.addClickListener((Button.ClickEvent event) -> { + AttachmentServer as = new AttachmentServer(); + //Get comment type + AttachmentType type = AttachmentTypeServer + .getTypeForExtension("comment"); + as.setAttachmentType(type); + displayComment(as); + }); + hl.addComponent(comment); + step.update(); + attach.setEnabled(!step.getLocked()); + bug.setEnabled(!step.getLocked()); + comment.setEnabled(!step.getLocked()); + result.setEnabled(!step.getLocked()); + layout.addComponent(hl); + return layout; + } + + private void displayIssue(IssueServer is) { + Panel form = new Panel("general.issue"); + FormLayout layout = new FormLayout(); + form.setContent(layout); + if (is.getIssuePK() == null) { + //Set creation date + is.setCreationTime(new Date()); + } + BeanFieldGroup binder = new BeanFieldGroup(is.getClass()); + binder.setItemDataSource(is); + Field title = binder.buildAndBind("general.summary", "title", + TextField.class); + title.setSizeFull(); + layout.addComponent(title); + Field desc = binder.buildAndBind("general.description", "description", + TextArea.class); + desc.setSizeFull(); + layout.addComponent(desc); + DateField creation = (DateField) binder.buildAndBind("creation.time", + "creationTime", + DateField.class); + creation.setReadOnly(true); + creation.setDateFormat(VMSettingServer.getSetting("date.format") + .getStringVal()); + creation.setResolution(Resolution.SECOND); + layout.addComponent(creation); + //Add the result + layout.addComponent(issueType); + if (is.getIssueType() != null) { + issueType.setValue(is.getIssueType().getTypeName()); + } else { + //Set it as observation + issueType.setValue("observation.name"); + } + //Lock if being created + issueType.setReadOnly(is.getIssueType() == null); + MessageBox mb = MessageBox.create(); + mb.setData(is); + mb.asModal(true) + .withMessage(layout) + .withButtonAlignment(Alignment.MIDDLE_CENTER) + .withOkButton(() -> { + try { + //Create the attachment + IssueServer issue = (IssueServer) mb.getData(); + issue.setDescription(((TextArea) desc).getValue().trim()); + issue.setIssueType(IssueTypeServer.getType((String) issueType.getValue())); + issue.setCreationTime(creation.getValue()); + issue.setTitle((String) title.getValue()); + boolean toAdd = issue.getIssuePK() == null; + issue.write2DB(); + if (toAdd) { + //Now add it to this Execution Step + if (getStep().getExecutionStepHasIssueList() == null) { + getStep().setExecutionStepHasIssueList(new ArrayList<>()); + } + getStep().addIssue(issue, ValidationManagerUI + .getInstance().getUser()); + getStep().write2DB(); + } + w.updateCurrentStep(); + } catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + } + }, ButtonOption.focus(), + ButtonOption.icon(VaadinIcons.CHECK), + ButtonOption.disable()) + .withCancelButton(ButtonOption.icon(VaadinIcons.CLOSE)); + mb.getWindow().setCaption("issue.detail"); + mb.getWindow().setIcon(ValidationManagerUI.SMALL_APP_ICON); + ((TextArea) desc).addTextChangeListener((TextChangeEvent event1) -> { + //Enable if there is a description change. + mb.getButton(ButtonType.OK) + .setEnabled(!step.getLocked() + && !event1.getText().trim().isEmpty()); + }); + ((TextField) title).addTextChangeListener((TextChangeEvent event1) -> { + //Enable if there is a title change. + mb.getButton(ButtonType.OK) + .setEnabled(!step.getLocked() + && !event1.getText().trim().isEmpty()); + }); + mb.open(); + } + + private void displayComment(AttachmentServer as) { + Panel form = new Panel("general.comment"); + FormLayout layout = new FormLayout(); + form.setContent(layout); + BeanFieldGroup binder = new BeanFieldGroup(as.getClass()); + binder.setItemDataSource(as); + Field desc = binder.buildAndBind("general.text", "textValue", + TextArea.class); + desc.setSizeFull(); + layout.addComponent(desc); + MessageBox mb = MessageBox.create(); + mb.setData(as); + mb.asModal(true) + .withMessage(desc) + .withButtonAlignment(Alignment.MIDDLE_CENTER) + .withOkButton(() -> { + try { + //Create the attachment + AttachmentServer a = (AttachmentServer) mb.getData(); + a.setTextValue(((TextArea) desc).getValue().trim()); + boolean toAdd = a.getAttachmentPK() == null; + a.write2DB(); + if (toAdd) { + //Now add it to this Execution Step + if (getStep().getExecutionStepHasAttachmentList() == null) { + getStep().setExecutionStepHasAttachmentList(new ArrayList<>()); + } + getStep().addAttachment(a); + getStep().write2DB(); + } + w.updateCurrentStep(); + } catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + } + }, ButtonOption.focus(), + ButtonOption.icon(VaadinIcons.CHECK), + ButtonOption.disable()) + .withCancelButton(ButtonOption.icon(VaadinIcons.CLOSE)); + mb.getWindow().setCaption("enter.comment"); + mb.getWindow().setIcon(ValidationManagerUI.SMALL_APP_ICON); + ((TextArea) desc).addTextChangeListener((TextChangeEvent event1) -> { + //Enable only when there is a comment. + mb.getButton(ButtonType.OK) + .setEnabled(!step.getLocked() + && !event1.getText().trim().isEmpty()); + }); + mb.open(); + } + + @Override + public boolean onAdvance() { + //Can only proceed after the current step is executed and documented. + String answer = ((String) result.getValue()); + String answer2 = ((String) review.getValue()); + if (answer == null) { + Notification.show("unable.to.proceed", + result.getRequiredError(), + Notification.Type.WARNING_MESSAGE); + } else if (reviewer && answer2 == null) { + Notification.show("unable.to.proceed", + review.getRequiredError(), + Notification.Type.WARNING_MESSAGE); + } else { + try { + //Save the result + ExecutionResult newResult = ExecutionResultServer + .getResult(answer); + ReviewResult newReview = ReviewResultServer.getReview(answer2); + getStep().setExecutionStart(start.getValue()); + if (getStep().getResultId() == null + || !Objects.equals(step.getResultId().getId(), + newResult.getId())) { + getStep().setResultId(newResult); + //Set end date to null to reflect update + getStep().setExecutionEnd(null); + } + if (getStep().getReviewResultId() == null + || !Objects.equals(step.getReviewResultId().getId(), + newReview.getId())) { + getStep().setReviewResultId(newReview); + //Set end date to null to reflect update + getStep().setReviewer(ValidationManagerUI.getInstance().getUser()); + } + if (getStep().getExecutionEnd() == null) { + getStep().setExecutionEnd(new Date()); + } + if (reviewer && getStep().getReviewDate() == null) { + getStep().setReviewDate(new Date()); + } + } catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + boolean validAnswer = result.getValue() != null + && !((String) result.getValue()).trim().isEmpty(); + boolean validReview = review.getValue() != null + && !((String) review.getValue()).trim().isEmpty(); + return reviewer ? validReview && validAnswer : validAnswer; + } + + @Override + public boolean onBack() { + return getStep().getStep().getStepSequence() > 1; + } + + /** + * @return the step + */ + public ExecutionStepServer getStep() { + return step; + } + + public static boolean getPDFRendering(File source, File dest) + throws IllegalStateException { + OfficeManager officeManager = null; + try { + File home = new File(VMSettingServer.getSetting("openoffice.home") + .getStringVal()); + int port = VMSettingServer + .getSetting("openoffice.port").getIntVal(); + if (!home.isDirectory() || !home.exists()) { + LOG.log(Level.WARNING, + "Unable to find OpenOffice and/or LibreOffice " + + "installation at: {0}", home); + Notification.show("unable.to.render.pdf.title", + "unable.to.render.pdf.message", + Notification.Type.ERROR_MESSAGE); + return false; + } + if (port <= 0) { + LOG.log(Level.WARNING, + "Unable to find OpenOffice and/or LibreOffice " + + "installation at port: {0}", port); + Notification.show("unable.to.render.pdf.title", + "unable.to.render.pdf.port", + Notification.Type.ERROR_MESSAGE); + return false; + } + // Connect to an OpenOffice.org instance running on available port + try { + officeManager = new DefaultOfficeManagerBuilder() + .setPortNumber(port) + .setOfficeHome(home) + .build(); + officeManager.start(); + + OfficeDocumentConverter converter + = new OfficeDocumentConverter(officeManager); + converter.convert(source, dest); + // close the connection + officeManager.stop(); + return true; + } catch (IllegalStateException ise) { + //Looks like OpenOffice or LibreOffice is not installed + LOG.log(Level.WARNING, + "Unable to find OpenOffice and/or LibreOffice " + + "installation.", ise); + } + } catch (OfficeException e) { + if (officeManager != null) { + try { + officeManager.stop(); + } catch (OfficeException ex) { + LOG.log(Level.SEVERE, null, ex); + } + } + LOG.log(Level.SEVERE, null, e); + } + return false; + } + + private void displayAttachment(AttachmentServer attachment) { + String name = attachment.getFileName(); + byte[] bytes = attachment.getFile(); + boolean ableToDisplay = false; + try { + for (IFileDisplay fd : Lookup.getDefault() + .lookupAll(IFileDisplay.class)) { + if (fd.supportFile(new File(name))) { + ValidationManagerUI.getInstance() + .addWindow(fd.getViewer(fd.loadFile(name, + bytes))); + ableToDisplay = true; + break; + } + } + if (!ableToDisplay) { + //Convert file to pfd + PDFDisplay pdf = new PDFDisplay(); + File source = pdf.loadFile(name, bytes); + File dest = new File(System.getProperty("java.io.tmpdir") + + System.getProperty("file.separator") + + name.substring(0, name.lastIndexOf(".")) + + ".pdf"); + getPDFRendering(source, dest); + if (dest.exists()) { + ValidationManagerUI.getInstance().addWindow(pdf.getViewer(dest)); + ableToDisplay = true; + } + } + } catch (IOException ex) { + LOG.log(Level.SEVERE, + "Error loading attachment file: " + + name, ex); + } + if (!ableToDisplay) { + Notification.show("unable.to.render.pdf.title", + "unable.to.render.pdf.message", + Notification.Type.ERROR_MESSAGE); + } + } + + private MessageBox getDeletionPrompt(Object data) { + MessageBox mb = MessageBox.createQuestion(); + mb.setData(data); + mb.asModal(true) + .withMessage(new Label("remove.item.title")) + .withButtonAlignment(Alignment.MIDDLE_CENTER) + .withYesButton(() -> { + try { + if (mb.getData() instanceof ExecutionStepHasAttachment) { + getStep().removeAttachment(new AttachmentServer( + ((ExecutionStepHasAttachment) mb.getData()) + .getAttachment().getAttachmentPK())); + } + if (mb.getData() instanceof ExecutionStepHasIssue) { + getStep().removeIssue(new IssueServer( + ((ExecutionStepHasIssue) mb.getData()) + .getIssue())); + } + getStep().write2DB(); + getStep().update(); + w.updateCurrentStep(); + } catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + } + }, ButtonOption.focus(), + ButtonOption.icon(VaadinIcons.CHECK)) + .withNoButton(() -> { + if (mb.getData() instanceof ExecutionStepHasAttachment) { + ExecutionStepHasAttachment esha = (ExecutionStepHasAttachment) mb.getData(); + if (esha.getAttachment().getAttachmentType().getType().equals("comment")) { + displayComment(new AttachmentServer(esha + .getAttachment().getAttachmentPK())); + } else { + displayAttachment(new AttachmentServer(esha + .getAttachment().getAttachmentPK())); + } + } + if (mb.getData() instanceof ExecutionStepHasIssue) { + ExecutionStepHasIssue eshi = (ExecutionStepHasIssue) mb.getData(); + displayIssue(new IssueServer(eshi.getIssue())); + } + }, + ButtonOption.icon(VaadinIcons.CLOSE)); + mb.getWindow().setCaption("issue.details"); + mb.getWindow().setIcon(ValidationManagerUI.SMALL_APP_ICON); + return mb; + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/notification/NotificationManager.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/notification/NotificationManager.java index 2111d16b..f755a55c 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/notification/NotificationManager.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/notification/NotificationManager.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,39 +13,61 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web.notification; - -import com.validation.manager.core.api.notification.INotificationManager; -import com.validation.manager.core.api.notification.NotificationTypes; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.server.core.NotificationServer; -import com.validation.manager.core.server.core.NotificationTypeServer; -import java.util.Date; -import org.openide.util.lookup.ServiceProvider; - -@ServiceProvider(service = INotificationManager.class) -public class NotificationManager implements INotificationManager { - - @Override - public void addNotification(String message, NotificationTypes type, - VmUser target, VmUser author) throws Exception { - NotificationServer ns = new NotificationServer(); - ns.setAuthor(author); - ns.setTargetUser(target); - ns.setContent(message); - ns.setCreationDate(new Date()); - String selected; - switch (type) { - case TEST: - selected = "notification.test.pending"; - break; - case REVIEW: - selected = "notification.review.pending"; - break; - default: - selected = "general.notification"; - } - ns.setNotificationType(NotificationTypeServer.getType(selected)); - ns.write2DB(); - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.notification; + +import com.validation.manager.core.api.email.IEmailManager; +import com.validation.manager.core.api.internationalization.InternationalizationProvider; +import com.validation.manager.core.api.notification.INotificationManager; +import com.validation.manager.core.api.notification.NotificationTypes; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.server.core.NotificationServer; +import com.validation.manager.core.server.core.NotificationTypeServer; +import com.validation.manager.core.server.core.VMSettingServer; +import com.validation.manager.core.server.core.VMUserServer; +import java.util.Date; +import java.util.Locale; +import org.openide.util.Lookup; +import org.openide.util.lookup.ServiceProvider; + +@ServiceProvider(service = INotificationManager.class) +public class NotificationManager implements INotificationManager { + + private static final InternationalizationProvider TRANSLATOR + = Lookup.getDefault().lookup(InternationalizationProvider.class); + + @Override + public void addNotification(String message, NotificationTypes type, + VmUser target, VmUser author) throws Exception { + NotificationServer ns = new NotificationServer(); + ns.setAuthor(author); + ns.setTargetUser(target); + ns.setContent(message); + ns.setCreationDate(new Date()); + String selected; + switch (type) { + case TEST: + selected = "notification.test.pending"; + break; + case REVIEW: + selected = "notification.review.pending"; + break; + default: + selected = "general.notification"; + } + ns.setNotificationType(NotificationTypeServer.getType(selected)); + ns.write2DB(); + //If email is configured, send the user an email as well. + if (VMSettingServer.getSetting("mail.enable").getBoolVal() + && !target.getEmail().isEmpty()) { + Lookup.getDefault().lookup(IEmailManager.class) + .sendEmail(target.getEmail(), null, + author.getEmail().isEmpty() + ? new VMUserServer(1).getEmail() + : author.getEmail(), + TRANSLATOR.translate(selected, + new Locale(target.getLocale())), + TRANSLATOR.translate("notification.new", + new Locale(target.getLocale()))); + } + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/notification/NotificationScreenProvider.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/notification/NotificationScreenProvider.java index f6645f29..a1594c6b 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/notification/NotificationScreenProvider.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/notification/NotificationScreenProvider.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -31,6 +31,7 @@ import com.vaadin.ui.VerticalLayout; import com.validation.manager.core.DataBaseManager; import com.validation.manager.core.IMainContentProvider; +import com.validation.manager.core.VMException; import com.validation.manager.core.VMUI; import com.validation.manager.core.api.internationalization.InternationalizationProvider; import com.validation.manager.core.db.Notification; @@ -43,8 +44,8 @@ import java.util.Locale; import java.util.logging.Level; import java.util.logging.Logger; -import net.sourceforge.javydreamercsw.validation.manager.web.UserToStringConverter; import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; +import net.sourceforge.javydreamercsw.validation.manager.web.component.UserToStringConverter; import net.sourceforge.javydreamercsw.validation.manager.web.provider.AbstractProvider; import org.openide.util.Lookup; import org.openide.util.lookup.ServiceProvider; @@ -59,9 +60,6 @@ public class NotificationScreenProvider extends AbstractProvider { private static final Logger LOG = Logger.getLogger(NotificationScreenProvider.class.getSimpleName()); - private VerticalLayout vs = null; - private final InternationalizationProvider TRANSLATOR = Lookup.getDefault() - .lookup(InternationalizationProvider.class); @Override public boolean shouldDisplay() { @@ -76,16 +74,7 @@ public String getComponentCaption() { @Override public Component getContent() { - if (vs == null) { - update(); - } - return vs; - } - - @Override - public void update() { - vs = new VerticalLayout(); - super.update(); + VerticalLayout vs = new VerticalLayout(); //On top put a list of notifications BeanItemContainer container = new BeanItemContainer<>(Notification.class); @@ -201,7 +190,7 @@ public Class getPresentationType() { ns.write2DB(); ((VMUI) UI.getCurrent()).updateScreen(); ((VMUI) UI.getCurrent()).showTab(getComponentCaption()); - } catch (Exception ex) { + } catch (VMException ex) { LOG.log(Level.SEVERE, null, ex); } } @@ -217,7 +206,7 @@ public Class getPresentationType() { ns.write2DB(); ((VMUI) UI.getCurrent()).updateScreen(); ((VMUI) UI.getCurrent()).showTab(getComponentCaption()); - } catch (Exception ex) { + } catch (VMException ex) { LOG.log(Level.SEVERE, null, ex); } } @@ -238,9 +227,7 @@ public Class getPresentationType() { = new NotificationServer((Notification) n); ns.setAcknowledgeDate(new Date()); ns.write2DB(); - ((VMUI) UI.getCurrent()).updateScreen(); - ((VMUI) UI.getCurrent()).showTab(getComponentCaption()); - } catch (Exception ex) { + } catch (VMException ex) { LOG.log(Level.SEVERE, null, ex); } } @@ -250,6 +237,6 @@ public Class getPresentationType() { vs.addComponent(text); vs.setSizeFull(); vs.setId(getComponentCaption()); + return vs; } } - diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/profile/ProfileProvider.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/profile/ProfileProvider.java index 2b4145f4..944fe764 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/profile/ProfileProvider.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/profile/ProfileProvider.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,197 +13,37 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web.profile; - -import com.vaadin.data.fieldgroup.BeanFieldGroup; -import com.vaadin.event.FieldEvents; -import com.vaadin.event.FieldEvents.TextChangeListener; -import com.vaadin.icons.VaadinIcons; -import com.vaadin.ui.Alignment; -import com.vaadin.ui.Button; -import com.vaadin.ui.ComboBox; -import com.vaadin.ui.Component; -import com.vaadin.ui.Field; -import com.vaadin.ui.FormLayout; -import com.vaadin.ui.HorizontalLayout; -import com.vaadin.ui.Label; -import com.vaadin.ui.Notification; -import com.vaadin.ui.Panel; -import com.vaadin.ui.PasswordField; -import com.vaadin.ui.TextField; -import com.vaadin.ui.VerticalLayout; -import com.vaadin.ui.themes.ValoTheme; -import com.validation.manager.core.IMainContentProvider; -import com.validation.manager.core.api.internationalization.InternationalizationProvider; -import com.validation.manager.core.server.core.VMUserServer; -import com.validation.manager.core.tool.MD5; -import de.steinwedel.messagebox.ButtonOption; -import de.steinwedel.messagebox.MessageBox; -import java.util.logging.Level; -import java.util.logging.Logger; -import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; -import net.sourceforge.javydreamercsw.validation.manager.web.provider.AbstractProvider; -import org.openide.util.Exceptions; -import org.openide.util.Lookup; -import org.openide.util.lookup.ServiceProvider; - -/** - * The provider for the profile tab to manage your account. - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -@ServiceProvider(service = IMainContentProvider.class, position = 5) -public class ProfileProvider extends AbstractProvider { - - private static final Logger LOG - = Logger.getLogger(ProfileProvider.class.getSimpleName()); - - @Override - public boolean shouldDisplay() { - //Show whenever an user is logged in. - return ValidationManagerUI.getInstance().getUser() != null; - } - - @Override - public String getComponentCaption() { - return "message.admin.userProfile"; - } - - @Override - public Component getContent() { - VMUserServer user = ValidationManagerUI.getInstance().getUser(); - Panel form = new Panel(); - FormLayout layout = new FormLayout(); - form.setContent(layout); - form.addStyleName(ValoTheme.FORMLAYOUT_LIGHT); - BeanFieldGroup binder = new BeanFieldGroup(user.getClass()); - binder.setItemDataSource(user); - Field fn = binder.buildAndBind(Lookup.getDefault().lookup(InternationalizationProvider.class). - translate("general.first.name"), - "firstName", TextField.class); - layout.addComponent(fn); - Field ln = binder.buildAndBind(Lookup.getDefault().lookup(InternationalizationProvider.class). - translate("general.last.name"), - "lastName", TextField.class); - layout.addComponent(ln); - Field username = binder.buildAndBind(Lookup.getDefault().lookup(InternationalizationProvider.class). - translate("general.username"), - "username", TextField.class); - layout.addComponent(username); - PasswordField pw = (PasswordField) binder.buildAndBind( - Lookup.getDefault().lookup(InternationalizationProvider.class). - translate("general.password"), - "password", PasswordField.class); - PasswordChangeListener listener = new PasswordChangeListener(); - pw.addTextChangeListener(listener); - pw.setConverter(new UserPasswordConverter()); - layout.addComponent(pw); - Field email = binder.buildAndBind(Lookup.getDefault().lookup(InternationalizationProvider.class). - translate("general.email"), - "email", TextField.class); - layout.addComponent(email); - ComboBox locale = new ComboBox(Lookup.getDefault().lookup(InternationalizationProvider.class). - translate("general.locale")); - ValidationManagerUI.getAvailableLocales().forEach(l -> { - locale.addItem(l.toString()); - }); - if (user.getLocale() != null) { - locale.setValue(user.getLocale()); - } - layout.addComponent(locale); - Button update = new Button(Lookup.getDefault().lookup(InternationalizationProvider.class). - translate("general.update")); - update.addClickListener((Button.ClickEvent event) -> { - try { - VMUserServer us = new VMUserServer(user); - us.setFirstName((String) fn.getValue()); - us.setLastName((String) ln.getValue()); - us.setEmail((String) email.getValue()); - us.setUsername((String) username.getValue()); - us.setLocale((String) locale.getValue()); - String password = (String) pw.getValue(); - if (listener.isChanged() && !password.equals(user.getPassword())) { - //Different password. Prompt for confirmation - MessageBox mb = MessageBox.create(); - VerticalLayout vl = new VerticalLayout(); - Label l = new Label(Lookup.getDefault().lookup(InternationalizationProvider.class). - translate("password.confirm.pw.message")); - vl.addComponent(l); - PasswordField np = new PasswordField(Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate("general.password")); - vl.addComponent(np); - mb.asModal(true) - .withCaption(Lookup.getDefault() - .lookup(InternationalizationProvider.class). - translate("password.confirm.pw")) - .withMessage(vl) - .withButtonAlignment(Alignment.MIDDLE_CENTER) - .withOkButton(() -> { - try { - if (password.equals(MD5.encrypt(np.getValue()))) { - us.setHashPassword(true); - us.setPassword(np.getValue()); - us.write2DB(); - Notification.show(Lookup.getDefault().lookup(InternationalizationProvider.class). - translate("audit.user.account.password.change"), - Notification.Type.ASSISTIVE_NOTIFICATION); - } else { - Notification.show(Lookup.getDefault().lookup(InternationalizationProvider.class). - translate("password.does.not.match"), - Notification.Type.WARNING_MESSAGE); - } - mb.close(); - } catch (Exception ex) { - Exceptions.printStackTrace(ex); - } - }, ButtonOption.focus(), - ButtonOption.closeOnClick(false), - ButtonOption.icon(VaadinIcons.CHECK)) - .withCancelButton( - ButtonOption.icon(VaadinIcons.CLOSE) - ).getWindow().setIcon(ValidationManagerUI.SMALL_APP_ICON); - mb.open(); - } else { - us.write2DB(); - } - ValidationManagerUI.getInstance().setUser(us); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - Notification.show(Lookup.getDefault().lookup(InternationalizationProvider.class). - translate("general.error.record.update"), - ex.getLocalizedMessage(), - Notification.Type.ERROR_MESSAGE); - } - }); - Button cancel = new Button(Lookup.getDefault() - .lookup(InternationalizationProvider.class). - translate("general.cancel")); - cancel.addClickListener((Button.ClickEvent event) -> { - binder.discard(); - ValidationManagerUI.getInstance().updateScreen(); - }); - HorizontalLayout hl = new HorizontalLayout(); - hl.addComponent(update); - hl.addComponent(cancel); - layout.addComponent(hl); - return form; - } - - private class PasswordChangeListener implements TextChangeListener { - - private boolean changed = false; - - @Override - public void textChange(FieldEvents.TextChangeEvent event) { - changed = true; - } - - /** - * @return the changed - */ - public boolean isChanged() { - return changed; - } - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.profile; + +import com.vaadin.ui.Component; +import com.validation.manager.core.IMainContentProvider; +import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; +import net.sourceforge.javydreamercsw.validation.manager.web.component.UserComponent; +import net.sourceforge.javydreamercsw.validation.manager.web.provider.AbstractProvider; +import org.openide.util.lookup.ServiceProvider; + +/** + * The provider for the profile tab to manage your account. + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +@ServiceProvider(service = IMainContentProvider.class, position = 5) +public class ProfileProvider extends AbstractProvider { + + @Override + public boolean shouldDisplay() { + //Show whenever an user is logged in. + return ValidationManagerUI.getInstance().getUser() != null; + } + + @Override + public String getComponentCaption() { + return "message.admin.userProfile"; + } + + @Override + public Component getContent() { + return new UserComponent(ValidationManagerUI.getInstance().getUser(), + true); + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/tester/ExecutionScreen.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/tester/ExecutionScreen.java index bd560157..9cc270c3 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/tester/ExecutionScreen.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/tester/ExecutionScreen.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,367 +13,361 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web.tester; - -import com.vaadin.event.Action; -import com.vaadin.icons.VaadinIcons; -import com.vaadin.ui.Button; -import com.vaadin.ui.Component; -import com.vaadin.ui.HorizontalLayout; -import com.vaadin.ui.Label; -import com.vaadin.ui.Table; -import com.vaadin.ui.TreeTable; -import com.vaadin.ui.VerticalLayout; -import com.vaadin.ui.themes.ValoTheme; -import com.validation.manager.core.api.internationalization.InternationalizationProvider; -import com.validation.manager.core.db.ExecutionStep; -import com.validation.manager.core.db.ExecutionStepPK; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.TestCaseExecution; -import com.validation.manager.core.server.core.ExecutionStepServer; -import com.validation.manager.core.server.core.ProjectServer; -import com.validation.manager.core.server.core.TestCaseExecutionServer; -import java.time.LocalDateTime; -import java.time.ZoneId; -import java.time.format.DateTimeFormatter; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.StringTokenizer; -import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; -import net.sourceforge.javydreamercsw.validation.manager.web.execution.ExecutionWindow; -import net.sourceforge.javydreamercsw.validation.manager.web.provider.AbstractProvider; -import net.sourceforge.javydreamercsw.validation.manager.web.quality.QualityScreenProvider; -import org.openide.util.Lookup; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public abstract class ExecutionScreen extends AbstractProvider { - - private ExecutionWindow executionWindow = null; - private final TreeTable testCaseTree - = new TreeTable("available.tests"); - - public ExecutionScreen() { - testCaseTree.setAnimationsEnabled(true); - testCaseTree.addContainerProperty("general.name", - String.class, ""); - testCaseTree.addGeneratedColumn("general.status", - (Table source, Object itemId, Object columnId) -> { - if (Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("general.status").equals(columnId) - && itemId instanceof String) { - String id = (String) itemId; - String message; - HorizontalLayout icons = new HorizontalLayout(); - Button label = new Button(); - Button label2 = new Button(); - icons.addComponent(label2); - icons.addComponent(label); - label.addStyleName(ValoTheme.BUTTON_BORDERLESS - + " labelButton"); - label2.addStyleName(ValoTheme.BUTTON_BORDERLESS - + " labelButton"); - Map summary = new HashMap<>(); - boolean locked = false; - if (id.startsWith("tce")) { - TestCaseExecutionServer tce - = new TestCaseExecutionServer( - Integer.parseInt(id.substring(3))); - summary = getSummary(tce, -1); - locked = isLocked(tce); - } else if (id.startsWith("es")) { - ExecutionStepServer es - = new ExecutionStepServer(extractExecutionStepPK(id)); - summary = getSummary( - es.getTestCaseExecution(), - Integer.parseInt(id - .substring(id.lastIndexOf("-") + 1))); - locked = es.getLocked(); - } - if (locked) { - label2.setIcon(VaadinIcons.LOCK); - label2.setDescription(Lookup.getDefault() - .lookup(InternationalizationProvider.class).translate("message.locked")); - } - if (!summary.isEmpty()) { - if (summary.containsKey("result.fail")) { - //At least one failure means the test case is failing - message = "result.fail"; - } else if (summary.containsKey("result.blocked")) { - //It is blocked - message = "result.blocked"; - } else if (summary.containsKey("result.pending") - && !summary.containsKey("result.pass")) { - //Still not done - message = "result.pending"; - } else if (summary.containsKey("result.pending") - && summary.containsKey("result.pass")) { - //In progress - message = "result.progress"; - } else { - //All is pass - message = "result.pass"; - } - label.setCaption(Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate(message)); - label.setDescription(Lookup.getDefault() - .lookup(InternationalizationProvider.class) - .translate(message)); - //Completed. Now check result - switch (message) { - case "result.pass": - label.setIcon(VaadinIcons.CHECK); - break; - case "result.fail": - label.setIcon(VaadinIcons.CLOSE); - break; - case "result.blocked": - label.setIcon(VaadinIcons.PAUSE); - break; - case "result.pending": - label.setIcon(VaadinIcons.CLOCK); - break; - case "result.progress": - label.setIcon(VaadinIcons.AUTOMATION); - break; - default: - label.setIcon(VaadinIcons.CLOCK); - break; - } - return icons; - } - } - return new Label(); - }); - testCaseTree.addContainerProperty("general.summary", - String.class, ""); - testCaseTree.addContainerProperty("general.assignment.date", - String.class, ""); - testCaseTree.setVisibleColumns(new Object[]{ - "general.name", - "general.status", - "general.summary", - "general.assignment.date"}); - testCaseTree.addActionHandler(new Action.Handler() { - @Override - public Action[] getActions(Object target, Object sender) { - List actions = new ArrayList<>(); - if (target instanceof String) { - String t = (String) target; - int tcID = -1; - TestCaseExecutionServer tce = null; - if (t.startsWith("es")) { - tce = new TestCaseExecutionServer(new ExecutionStepServer( - extractExecutionStepPK(t)) - .getTestCaseExecution().getId()); - tcID = Integer.parseInt(t - .substring(t.lastIndexOf("-") + 1)); - } else if (t.startsWith("tce")) { - tce = new TestCaseExecutionServer( - Integer.parseInt(t.substring(3))); - } - if (!isLocked(tce, tcID) - && ExecutionScreen.this instanceof TesterScreenProvider) { - actions.add(new Action(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("general.execute"))); - } else if (isLocked(tce, tcID) - && ExecutionScreen.this instanceof QualityScreenProvider) { - actions.add(new Action(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("general.review"))); - } - } - return actions.toArray(new Action[actions.size()]); - } - - @Override - public void handleAction(Action action, Object sender, Object target) { - //Parse the information to get the exact Execution Step - List executions = new ArrayList<>(); - int tcID = -1; - if (((String) target).startsWith("tce")) { - executions.add(new TestCaseExecutionServer( - Integer.parseInt(((String) target).substring(3)))); - } else if (((String) target).startsWith("es")) { - executions.add(new TestCaseExecutionServer(new ExecutionStepServer( - extractExecutionStepPK((String) target)) - .getTestCaseExecution().getId())); - tcID = Integer.parseInt(((String) target) - .substring(((String) target).lastIndexOf("-") + 1)); - } - showExecutionScreen(executions, tcID); - } - }); - } - - protected Map getSummary(TestCaseExecution tce, int tcId) { - Map summary = new HashMap<>(); - tce.getExecutionStepList().forEach((ExecutionStep es) -> { - if (tcId == -1 || es.getStep().getTestCase().getId() == tcId) { - if (es.getExecutionStart() != null && es.getExecutionEnd() == null) { - //In progress - if (!summary.containsKey("progress")) { - summary.put("progress", 0); - } - summary.put("progress", summary.get("progress") + 1); - } else if (es.getResultId() == null - || (es.getExecutionStart() == null - && es.getExecutionEnd() == null)) { - //Not started - if (!summary.containsKey("result.pending")) { - summary.put("result.pending", 0); - } - summary.put("result.pending", summary.get("result.pending") + 1); - } else if (es.getExecutionStart() != null && es.getExecutionEnd() != null) { - if (!summary.containsKey(es.getResultId().getResultName())) { - summary.put(es.getResultId().getResultName(), 0); - } - summary.put(es.getResultId().getResultName(), - summary.get(es.getResultId().getResultName()) + 1); - } - } - }); - return summary; - } - - @Override - public boolean shouldDisplay() { - return ValidationManagerUI.getInstance().getUser() != null - && ValidationManagerUI.getInstance() - .checkRight("system.configuration"); - } - - protected ExecutionStepPK extractExecutionStepPK(String itemId) { - String id = itemId.substring(2); //Remove es - int esId; - int sId; - int tcId; - StringTokenizer st = new StringTokenizer(id, "-"); - esId = Integer.parseInt(st.nextToken()); - sId = Integer.parseInt(st.nextToken()); - tcId = Integer.parseInt(st.nextToken()); - return new ExecutionStepPK(esId, sId, tcId); - } - - protected void showExecutionScreen(List executions, - int tcID) { - if (executionWindow == null) { - executionWindow = new ExecutionWindow(executions, tcID, - this instanceof QualityScreenProvider); - executionWindow.setCaption(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("test.execution")); - executionWindow.setVisible(true); - executionWindow.setClosable(false); - executionWindow.setResizable(false); - executionWindow.center(); - executionWindow.setModal(true); - executionWindow.setSizeFull(); - } - if (!ValidationManagerUI.getInstance().getWindows().contains(executionWindow)) { - ValidationManagerUI.getInstance().addWindow(executionWindow); - } - } - - @Override - public Component getContent() { - VerticalLayout vl = new VerticalLayout(); - update(); - vl.addComponent(testCaseTree); - return vl; - } - - @Override - public void update() { - if (executionWindow != null) { - executionWindow.setCaption(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("test.execution")); - } - testCaseTree.setCaption(Lookup.getDefault().lookup(InternationalizationProvider.class) - .translate("available.tests")); - testCaseTree.removeAllItems(); - if (ValidationManagerUI.getInstance().getUser() != null) { - ProjectServer.getProjects().forEach(p -> { - if (p.getParentProjectId() == null) { - testCaseTree.addItem(new Object[]{p.getName(), - "", "",}, "p" + p.getId()); - testCaseTree.setItemIcon("p" + p.getId(), - ValidationManagerUI.PROJECT_ICON); - p.getProjectList().forEach(sp -> { - //Add subprojects - testCaseTree.addItem(new Object[]{sp.getName(), - "", "",}, "p" + sp.getId()); - testCaseTree.setParent("p" + sp.getId(), "p" + p.getId()); - testCaseTree.setItemIcon("p" + sp.getId(), - ValidationManagerUI.PROJECT_ICON); - //Add applicable Executions - Map tests = new HashMap<>(); - sp.getTestProjectList().forEach(test -> { - test.getTestPlanList().forEach(tp -> { - tp.getTestCaseList().forEach(testCase -> { - List tcids = new ArrayList<>(); - testCase.getStepList().forEach(s -> { - s.getExecutionStepList().forEach(es -> { - TestCaseExecution tce = es.getTestCaseExecution(); - testCaseTree.addItem(new Object[]{tce.getName(), - "", "",}, "tce" + tce.getId()); - testCaseTree.setParent("tce" + tce.getId(), - "p" + sp.getId()); - testCaseTree.setItemIcon("tce" + tce.getId(), - ValidationManagerUI.EXECUTION_ICON); - if (this instanceof QualityScreenProvider - && es.getLocked() - || (es.getAssignee() != null - && es.getAssignee().getId() - .equals(ValidationManagerUI.getInstance() - .getUser().getId()))) { - TestCase tc = es.getStep().getTestCase(); - if (!tcids.contains(tc.getId())) { - tcids.add(tc.getId()); - DateTimeFormatter format - = DateTimeFormatter.ofPattern("MMM d yyyy hh:mm a"); - LocalDateTime time - = LocalDateTime.ofInstant(es.getAssignedTime() - .toInstant(), ZoneId.systemDefault()); - String key = "es" + es.getExecutionStepPK().getTestCaseExecutionId() - + "-" + es.getStep().getStepPK().getId() - + "-" + tc.getId(); - testCaseTree.addItem(new Object[]{tc.getName(), - tc.getSummary(), format.format(time),}, - key); - testCaseTree.setParent(key, "tce" - + tce.getId()); - testCaseTree.setItemIcon(key, - ValidationManagerUI.TEST_ICON); - testCaseTree.setChildrenAllowed(key, false); - } - } - }); - }); - tcids.clear(); - }); - }); - }); - //Make columns autofit - int count = 0; - for (Object id : testCaseTree.getVisibleColumns()) { - if (count < 2) { - testCaseTree.setColumnExpandRatio(id, 1.0f); - } - count++; - } - testCaseTree.setSizeFull(); - }); - } - }); - } - //Update column titles - for (String h : testCaseTree.getColumnHeaders()) { - testCaseTree.setColumnHeader(h, Lookup.getDefault() - .lookup(InternationalizationProvider.class).translate(h)); - } - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.tester; + +import com.vaadin.event.Action; +import com.vaadin.icons.VaadinIcons; +import com.vaadin.ui.Button; +import com.vaadin.ui.Component; +import com.vaadin.ui.HorizontalLayout; +import com.vaadin.ui.Label; +import com.vaadin.ui.Table; +import com.vaadin.ui.TreeTable; +import com.vaadin.ui.VerticalLayout; +import com.vaadin.ui.themes.ValoTheme; +import com.validation.manager.core.db.ExecutionStep; +import com.validation.manager.core.db.ExecutionStepPK; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.TestCaseExecution; +import com.validation.manager.core.server.core.ExecutionStepServer; +import com.validation.manager.core.server.core.ProjectServer; +import com.validation.manager.core.server.core.TestCaseExecutionServer; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.StringTokenizer; +import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; +import net.sourceforge.javydreamercsw.validation.manager.web.execution.ExecutionWindow; +import net.sourceforge.javydreamercsw.validation.manager.web.provider.AbstractProvider; +import net.sourceforge.javydreamercsw.validation.manager.web.quality.QualityScreenProvider; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public abstract class ExecutionScreen extends AbstractProvider { + + private ExecutionWindow executionWindow = null; + private final TreeTable testCaseTree + = new TreeTable("available.tests"); + + public ExecutionScreen() { + testCaseTree.setAnimationsEnabled(true); + testCaseTree.addContainerProperty("general.name", + String.class, ""); + testCaseTree.addGeneratedColumn("general.status", + (Table source, Object itemId, Object columnId) -> { + if (TRANSLATOR + .translate("general.status").equals(columnId) + && itemId instanceof String) { + String id = (String) itemId; + String message; + HorizontalLayout icons = new HorizontalLayout(); + Button label = new Button(); + Button label2 = new Button(); + icons.addComponent(label2); + icons.addComponent(label); + label.addStyleName(ValoTheme.BUTTON_BORDERLESS + + " labelButton"); + label2.addStyleName(ValoTheme.BUTTON_BORDERLESS + + " labelButton"); + Map summary = new HashMap<>(); + boolean locked = false; + if (id.startsWith("tce")) { + TestCaseExecutionServer tce + = new TestCaseExecutionServer( + Integer.parseInt(id.substring(3))); + summary = getSummary(tce, -1); + locked = isLocked(tce); + } else if (id.startsWith("es")) { + ExecutionStepServer es + = new ExecutionStepServer(extractExecutionStepPK(id)); + summary = getSummary( + es.getTestCaseExecution(), + Integer.parseInt(id + .substring(id.lastIndexOf("-") + 1))); + locked = es.getLocked(); + } + if (locked) { + label2.setIcon(VaadinIcons.LOCK); + label2.setDescription(TRANSLATOR.translate("message.locked")); + } + if (!summary.isEmpty()) { + if (summary.containsKey("result.fail")) { + //At least one failure means the test case is failing + message = "result.fail"; + } else if (summary.containsKey("result.blocked")) { + //It is blocked + message = "result.blocked"; + } else if (summary.containsKey("result.pending") + && !summary.containsKey("result.pass")) { + //Still not done + message = "result.pending"; + } else if (summary.containsKey("result.pending") + && summary.containsKey("result.pass")) { + //In progress + message = "result.progress"; + } else { + //All is pass + message = "result.pass"; + } + label.setCaption(TRANSLATOR + .translate(message)); + label.setDescription(TRANSLATOR + .translate(message)); + //Completed. Now check result + switch (message) { + case "result.pass": + label.setIcon(VaadinIcons.CHECK); + break; + case "result.fail": + label.setIcon(VaadinIcons.CLOSE); + break; + case "result.blocked": + label.setIcon(VaadinIcons.PAUSE); + break; + case "result.pending": + label.setIcon(VaadinIcons.CLOCK); + break; + case "result.progress": + label.setIcon(VaadinIcons.AUTOMATION); + break; + default: + label.setIcon(VaadinIcons.CLOCK); + break; + } + return icons; + } + } + return new Label(); + }); + testCaseTree.addContainerProperty("general.summary", + String.class, ""); + testCaseTree.addContainerProperty("general.assignment.date", + String.class, ""); + testCaseTree.setVisibleColumns(new Object[]{ + "general.name", + "general.status", + "general.summary", + "general.assignment.date"}); + testCaseTree.addActionHandler(new Action.Handler() { + @Override + public Action[] getActions(Object target, Object sender) { + List actions = new ArrayList<>(); + if (target instanceof String) { + String t = (String) target; + int tcID = -1; + TestCaseExecutionServer tce = null; + if (t.startsWith("es")) { + tce = new TestCaseExecutionServer(new ExecutionStepServer( + extractExecutionStepPK(t)) + .getTestCaseExecution().getId()); + tcID = Integer.parseInt(t + .substring(t.lastIndexOf("-") + 1)); + } else if (t.startsWith("tce")) { + tce = new TestCaseExecutionServer( + Integer.parseInt(t.substring(3))); + } + if (!isLocked(tce, tcID) + && ExecutionScreen.this instanceof TesterScreenProvider) { + actions.add(new Action(TRANSLATOR + .translate("general.execute"))); + } else if (isLocked(tce, tcID) + && ExecutionScreen.this instanceof QualityScreenProvider) { + actions.add(new Action(TRANSLATOR + .translate("general.review"))); + } + } + return actions.toArray(new Action[actions.size()]); + } + + @Override + public void handleAction(Action action, Object sender, Object target) { + //Parse the information to get the exact Execution Step + List executions = new ArrayList<>(); + int tcID = -1; + if (((String) target).startsWith("tce")) { + executions.add(new TestCaseExecutionServer( + Integer.parseInt(((String) target).substring(3)))); + } else if (((String) target).startsWith("es")) { + executions.add(new TestCaseExecutionServer(new ExecutionStepServer( + extractExecutionStepPK((String) target)) + .getTestCaseExecution().getId())); + tcID = Integer.parseInt(((String) target) + .substring(((String) target).lastIndexOf("-") + 1)); + } + showExecutionScreen(executions, tcID); + } + }); + } + + protected Map getSummary(TestCaseExecution tce, int tcId) { + Map summary = new HashMap<>(); + tce.getExecutionStepList().forEach((ExecutionStep es) -> { + if (tcId == -1 || es.getStep().getTestCase().getId() == tcId) { + if (es.getExecutionStart() != null && es.getExecutionEnd() == null) { + //In progress + if (!summary.containsKey("progress")) { + summary.put("progress", 0); + } + summary.put("progress", summary.get("progress") + 1); + } else if (es.getResultId() == null + || (es.getExecutionStart() == null + && es.getExecutionEnd() == null)) { + //Not started + if (!summary.containsKey("result.pending")) { + summary.put("result.pending", 0); + } + summary.put("result.pending", summary.get("result.pending") + 1); + } else if (es.getExecutionStart() != null && es.getExecutionEnd() != null) { + if (!summary.containsKey(es.getResultId().getResultName())) { + summary.put(es.getResultId().getResultName(), 0); + } + summary.put(es.getResultId().getResultName(), + summary.get(es.getResultId().getResultName()) + 1); + } + } + }); + return summary; + } + + @Override + public boolean shouldDisplay() { + return ValidationManagerUI.getInstance().getUser() != null + && ValidationManagerUI.getInstance() + .checkRight("system.configuration"); + } + + protected ExecutionStepPK extractExecutionStepPK(String itemId) { + String id = itemId.substring(2); //Remove es + int esId; + int sId; + int tcId; + StringTokenizer st = new StringTokenizer(id, "-"); + esId = Integer.parseInt(st.nextToken()); + sId = Integer.parseInt(st.nextToken()); + tcId = Integer.parseInt(st.nextToken()); + return new ExecutionStepPK(esId, sId, tcId); + } + + protected void showExecutionScreen(List executions, + int tcID) { + if (executionWindow == null) { + executionWindow = new ExecutionWindow(executions, tcID, + this instanceof QualityScreenProvider); + executionWindow.setCaption(TRANSLATOR + .translate("test.execution")); + executionWindow.setVisible(true); + executionWindow.setClosable(false); + executionWindow.setResizable(false); + executionWindow.center(); + executionWindow.setModal(true); + executionWindow.setSizeFull(); + } + if (!ValidationManagerUI.getInstance().getWindows().contains(executionWindow)) { + ValidationManagerUI.getInstance().addWindow(executionWindow); + } + } + + @Override + public Component getContent() { + VerticalLayout vl = new VerticalLayout(); + update(); + vl.addComponent(testCaseTree); + return vl; + } + + @Override + public void update() { + if (executionWindow != null) { + executionWindow.setCaption(TRANSLATOR + .translate("test.execution")); + } + testCaseTree.setCaption(TRANSLATOR + .translate("available.tests")); + testCaseTree.removeAllItems(); + if (ValidationManagerUI.getInstance().getUser() != null) { + ProjectServer.getProjects().forEach(p -> { + if (p.getParentProjectId() == null) { + testCaseTree.addItem(new Object[]{p.getName(), + "", "",}, "p" + p.getId()); + testCaseTree.setItemIcon("p" + p.getId(), + ValidationManagerUI.PROJECT_ICON); + p.getProjectList().forEach(sp -> { + //Add subprojects + testCaseTree.addItem(new Object[]{sp.getName(), + "", "",}, "p" + sp.getId()); + testCaseTree.setParent("p" + sp.getId(), "p" + p.getId()); + testCaseTree.setItemIcon("p" + sp.getId(), + ValidationManagerUI.PROJECT_ICON); + //Add applicable Executions + Map tests = new HashMap<>(); + sp.getTestProjectList().forEach(test -> { + test.getTestPlanList().forEach(tp -> { + tp.getTestCaseList().forEach(testCase -> { + List tcids = new ArrayList<>(); + testCase.getStepList().forEach(s -> { + s.getExecutionStepList().forEach(es -> { + TestCaseExecution tce = es.getTestCaseExecution(); + testCaseTree.addItem(new Object[]{tce.getName(), + "", "",}, "tce" + tce.getId()); + testCaseTree.setParent("tce" + tce.getId(), + "p" + sp.getId()); + testCaseTree.setItemIcon("tce" + tce.getId(), + ValidationManagerUI.EXECUTION_ICON); + if (this instanceof QualityScreenProvider + && es.getLocked() + || (es.getAssignee() != null + && es.getAssignee().getId() + .equals(ValidationManagerUI.getInstance() + .getUser().getId()))) { + TestCase tc = es.getStep().getTestCase(); + if (!tcids.contains(tc.getId())) { + tcids.add(tc.getId()); + DateTimeFormatter format + = DateTimeFormatter.ofPattern("MMM d yyyy hh:mm a"); + LocalDateTime time + = LocalDateTime.ofInstant(es.getAssignedTime() + .toInstant(), ZoneId.systemDefault()); + String key = "es" + es.getExecutionStepPK().getTestCaseExecutionId() + + "-" + es.getStep().getStepPK().getId() + + "-" + tc.getId(); + testCaseTree.addItem(new Object[]{tc.getName(), + tc.getSummary(), format.format(time),}, + key); + testCaseTree.setParent(key, "tce" + + tce.getId()); + testCaseTree.setItemIcon(key, + ValidationManagerUI.TEST_ICON); + testCaseTree.setChildrenAllowed(key, false); + } + } + }); + }); + tcids.clear(); + }); + }); + }); + //Make columns autofit + int count = 0; + for (Object id : testCaseTree.getVisibleColumns()) { + if (count < 2) { + testCaseTree.setColumnExpandRatio(id, 1.0f); + } + count++; + } + testCaseTree.setSizeFull(); + }); + } + }); + } + //Update column titles + for (String h : testCaseTree.getColumnHeaders()) { + testCaseTree.setColumnHeader(h, TRANSLATOR.translate(h)); + } + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/assign/AssignUserStep.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/assign/AssignUserStep.java index e232e945..21c86d77 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/assign/AssignUserStep.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/assign/AssignUserStep.java @@ -13,150 +13,150 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web.wizard.assign; - -import com.vaadin.data.Item; -import com.vaadin.data.util.BeanItemContainer; -import com.vaadin.icons.VaadinIcons; -import com.vaadin.ui.AbstractSelect.ItemCaptionMode; -import com.vaadin.ui.Component; -import com.vaadin.ui.Notification; -import com.vaadin.ui.OptionGroup; -import com.vaadin.ui.TreeTable; -import com.vaadin.ui.VerticalLayout; -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.db.TestCase; -import com.validation.manager.core.db.VmUser; -import com.validation.manager.core.db.controller.TestCaseJpaController; -import com.validation.manager.core.server.core.RoleServer; -import com.validation.manager.core.server.core.TestCaseExecutionServer; -import com.validation.manager.core.server.core.TestCaseServer; -import com.validation.manager.core.server.core.VMUserServer; -import com.validation.manager.core.tool.TCEExtraction; -import com.validation.manager.core.tool.Tool; -import java.nio.charset.StandardCharsets; -import java.util.ArrayList; -import java.util.List; -import java.util.logging.Level; -import java.util.logging.Logger; -import net.sourceforge.javydreamercsw.validation.manager.web.TreeTableCheckBox; -import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; -import org.vaadin.teemu.wizards.WizardStep; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class AssignUserStep implements WizardStep { - - private final Object key; - private final TreeTable testTree - = new TreeTable("available.tests"); - private final OptionGroup userGroup - = new OptionGroup("available.tester"); - private TestCaseExecutionServer tce = null; - private TestCaseServer tc = null; - private static final Logger LOG - = Logger.getLogger(AssignUserStep.class.getSimpleName()); - private final ValidationManagerUI ui; - - public AssignUserStep(ValidationManagerUI ui, Object item) { - this.key = item; - this.ui = ui; - } - - @Override - public String getCaption() { - return "assign.test.case"; - } - - @Override - public Component getContent() { - VerticalLayout l = new VerticalLayout(); - List testCases = new ArrayList<>(); - List users = new ArrayList<>(); - TCEExtraction extracted = Tool.extractTCE(key); - tc = extracted.getTestCase(); - tce = extracted.getTestCaseExecution(); - if (tc != null) { - testCases.add(tc.getEntity()); - } else if (tce != null) { - tce.getExecutionStepList().stream().filter((es) - -> (!testCases.contains(es.getStep().getTestCase()))) - .forEachOrdered((es) -> { - testCases.add(es.getStep().getTestCase()); - }); - } - testTree.addContainerProperty("general.name", - TreeTableCheckBox.class, ""); - testTree.addContainerProperty("general.description", - String.class, ""); - testTree.setWidth("20em"); - testCases.forEach((t) -> { - testTree.addItem(new Object[]{new TreeTableCheckBox(testTree, - t.getName(), t.getId()), - t.getSummary() == null ? "" : new String(t.getSummary(), - StandardCharsets.UTF_8)}, t.getId()); - testTree.setChildrenAllowed(t.getId(), false); - }); - testTree.setPageLength(testCases.size() + 1); - testTree.setSizeFull(); - l.addComponent(testTree); - //Add list of testers - users.addAll(RoleServer.getRole("tester").getVmUserList()); - BeanItemContainer userContainer - = new BeanItemContainer<>(VmUser.class); - userContainer.addAll(users); - userGroup.setContainerDataSource(userContainer); - userGroup.setItemCaptionMode(ItemCaptionMode.EXPLICIT); - userGroup.getItemIds().forEach(id -> { - VmUser u = (VmUser) id; - userGroup.setItemCaption(id, u.getFirstName() + " " - + u.getLastName()); - userGroup.setItemIcon(id, VaadinIcons.USER); - }); - l.addComponent(userGroup); - return l; - } - - @Override - public boolean onAdvance() { - boolean selectedTestCase = false; - List testCaseIds = new ArrayList<>(); - for (Object id : testTree.getItemIds()) { - Item item = testTree.getItem(id); - Object val = item.getItemProperty("general.name").getValue(); - if (val instanceof TreeTableCheckBox) { - TreeTableCheckBox ttcb = (TreeTableCheckBox) val; - if (ttcb.getValue()) { - selectedTestCase = true; - testCaseIds.add((Integer) id); - } - } - } - if (!selectedTestCase) { - Notification.show("unable.to.proceed", - "select.test.case.message", - Notification.Type.WARNING_MESSAGE); - return false; - } - try { - //Now process the data - VMUserServer user = new VMUserServer((VmUser) userGroup.getValue()); - TestCaseJpaController c - = new TestCaseJpaController(DataBaseManager - .getEntityManagerFactory()); - testCaseIds.forEach((id) -> { - user.assignTestCase(tce, c.findTestCase(id), ui.getUser()); - }); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - return true; - } - - @Override - public boolean onBack() { - return false; - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.wizard.assign; + +import com.vaadin.data.Item; +import com.vaadin.data.util.BeanItemContainer; +import com.vaadin.icons.VaadinIcons; +import com.vaadin.ui.AbstractSelect.ItemCaptionMode; +import com.vaadin.ui.Component; +import com.vaadin.ui.Notification; +import com.vaadin.ui.OptionGroup; +import com.vaadin.ui.TreeTable; +import com.vaadin.ui.VerticalLayout; +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.db.TestCase; +import com.validation.manager.core.db.VmUser; +import com.validation.manager.core.db.controller.TestCaseJpaController; +import com.validation.manager.core.server.core.RoleServer; +import com.validation.manager.core.server.core.TestCaseExecutionServer; +import com.validation.manager.core.server.core.TestCaseServer; +import com.validation.manager.core.server.core.VMUserServer; +import com.validation.manager.core.tool.TCEExtraction; +import com.validation.manager.core.tool.Tool; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; +import net.sourceforge.javydreamercsw.validation.manager.web.component.TreeTableCheckBox; +import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; +import org.vaadin.teemu.wizards.WizardStep; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class AssignUserStep implements WizardStep { + + private final Object key; + private final TreeTable testTree + = new TreeTable("available.tests"); + private final OptionGroup userGroup + = new OptionGroup("available.tester"); + private TestCaseExecutionServer tce = null; + private TestCaseServer tc = null; + private static final Logger LOG + = Logger.getLogger(AssignUserStep.class.getSimpleName()); + private final ValidationManagerUI ui; + + public AssignUserStep(ValidationManagerUI ui, Object item) { + this.key = item; + this.ui = ui; + } + + @Override + public String getCaption() { + return "assign.test.case"; + } + + @Override + public Component getContent() { + VerticalLayout l = new VerticalLayout(); + List testCases = new ArrayList<>(); + List users = new ArrayList<>(); + TCEExtraction extracted = Tool.extractTCE(key); + tc = extracted.getTestCase(); + tce = extracted.getTestCaseExecution(); + if (tc != null) { + testCases.add(tc.getEntity()); + } else if (tce != null) { + tce.getExecutionStepList().stream().filter((es) + -> (!testCases.contains(es.getStep().getTestCase()))) + .forEachOrdered((es) -> { + testCases.add(es.getStep().getTestCase()); + }); + } + testTree.addContainerProperty("general.name", + TreeTableCheckBox.class, ""); + testTree.addContainerProperty("general.description", + String.class, ""); + testTree.setWidth("20em"); + testCases.forEach((t) -> { + testTree.addItem(new Object[]{new TreeTableCheckBox(testTree, + t.getName(), t.getId()), + t.getSummary() == null ? "" : new String(t.getSummary(), + StandardCharsets.UTF_8)}, t.getId()); + testTree.setChildrenAllowed(t.getId(), false); + }); + testTree.setPageLength(testCases.size() + 1); + testTree.setSizeFull(); + l.addComponent(testTree); + //Add list of testers + users.addAll(RoleServer.getRole("tester").getVmUserList()); + BeanItemContainer userContainer + = new BeanItemContainer<>(VmUser.class); + userContainer.addAll(users); + userGroup.setContainerDataSource(userContainer); + userGroup.setItemCaptionMode(ItemCaptionMode.EXPLICIT); + userGroup.getItemIds().forEach(id -> { + VmUser u = (VmUser) id; + userGroup.setItemCaption(id, u.getFirstName() + " " + + u.getLastName()); + userGroup.setItemIcon(id, VaadinIcons.USER); + }); + l.addComponent(userGroup); + return l; + } + + @Override + public boolean onAdvance() { + boolean selectedTestCase = false; + List testCaseIds = new ArrayList<>(); + for (Object id : testTree.getItemIds()) { + Item item = testTree.getItem(id); + Object val = item.getItemProperty("general.name").getValue(); + if (val instanceof TreeTableCheckBox) { + TreeTableCheckBox ttcb = (TreeTableCheckBox) val; + if (ttcb.getValue()) { + selectedTestCase = true; + testCaseIds.add((Integer) id); + } + } + } + if (!selectedTestCase) { + Notification.show("unable.to.proceed", + "select.test.case.message", + Notification.Type.WARNING_MESSAGE); + return false; + } + try { + //Now process the data + VMUserServer user = new VMUserServer((VmUser) userGroup.getValue()); + TestCaseJpaController c + = new TestCaseJpaController(DataBaseManager + .getEntityManagerFactory()); + testCaseIds.forEach((id) -> { + user.assignTestCase(tce, c.findTestCase(id), ui.getUser()); + }); + } catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + } + return true; + } + + @Override + public boolean onBack() { + return false; + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/plan/DetailStep.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/plan/DetailStep.java index 6f91fa22..54c881c9 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/plan/DetailStep.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/plan/DetailStep.java @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017 Javier A. Ortiz Bultron javier.ortiz.78@gmail.com. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,127 +13,127 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web.wizard.plan; - -import com.vaadin.data.fieldgroup.BeanFieldGroup; -import com.vaadin.ui.Component; -import com.vaadin.ui.FormLayout; -import com.vaadin.ui.Panel; -import com.vaadin.ui.TextArea; -import com.vaadin.ui.themes.ValoTheme; -import com.validation.manager.core.DataBaseManager; -import com.validation.manager.core.VMUI; -import com.validation.manager.core.db.TestCaseExecution; -import com.validation.manager.core.db.controller.TestCaseExecutionJpaController; -import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; -import com.validation.manager.core.server.core.TestCaseExecutionServer; -import com.validation.manager.core.server.core.TestCaseServer; -import java.util.List; -import java.util.logging.Level; -import java.util.logging.Logger; -import net.sourceforge.javydreamercsw.validation.manager.web.ByteToStringConverter; -import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; -import org.vaadin.teemu.wizards.WizardStep; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class DetailStep implements WizardStep { - - private List testCases; - private final TestCaseExecution tce; - private static final Logger LOG - = Logger.getLogger(DetailStep.class.getSimpleName()); - - public DetailStep() { - this.tce = new TestCaseExecution(); - } - - @Override - public String getCaption() { - return "add.details"; - } - - @Override - public Component getContent() { - Panel form = new Panel("execution.detail"); - FormLayout layout = new FormLayout(); - form.setContent(layout); - form.addStyleName(ValoTheme.FORMLAYOUT_LIGHT); - BeanFieldGroup binder = new BeanFieldGroup(TestCaseExecution.class); - binder.setItemDataSource(tce); - TextArea name = new TextArea("general.name"); - name.setConverter(new ByteToStringConverter()); - binder.bind(name, "name"); - layout.addComponent(name); - TextArea scope = new TextArea("general.scope"); - scope.setConverter(new ByteToStringConverter()); - binder.bind(scope, "scope"); - layout.addComponent(scope); - if (tce.getId() != null) { - TextArea conclusion = new TextArea("general.comclusion"); - conclusion.setConverter(new ByteToStringConverter()); - binder.bind(conclusion, "conclusion"); - layout.addComponent(conclusion); - conclusion.setSizeFull(); - layout.addComponent(conclusion); - } - binder.setBuffered(false); - binder.bindMemberFields(form); - form.setSizeFull(); - return form; - } - - @Override - public boolean onAdvance() { - try { - //Create the record - new TestCaseExecutionJpaController(DataBaseManager - .getEntityManagerFactory()).create(tce); - TestCaseExecutionServer tces = new TestCaseExecutionServer(tce); - //Now create the execution records - TestCaseServer tc; - for (Integer id : testCases) { - //Retrieve the TestCase to get the steps - tc = new TestCaseServer(id); - tces.addTestCase(tc.getEntity()); - } - try { - tces.write2DB(); - VMUI ui = ValidationManagerUI.getInstance(); - ui.buildProjectTree(ui.getSelectdValue()); - ui.updateProjectList(); - ui.updateScreen(); - ui.displayObject(tces.getEntity(), false); - return true; - } catch (NonexistentEntityException ex) { - LOG.log(Level.SEVERE, null, ex); - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - } catch (Exception ex) { - LOG.log(Level.SEVERE, null, ex); - } - return false; - } - - @Override - public boolean onBack() { - return true; - } - - /** - * @return the testCases - */ - public List getTestCases() { - return testCases; - } - - /** - * @param testCases the testCases to set - */ - public void setTestCases(List testCases) { - this.testCases = testCases; - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.wizard.plan; + +import com.vaadin.data.fieldgroup.BeanFieldGroup; +import com.vaadin.ui.Component; +import com.vaadin.ui.FormLayout; +import com.vaadin.ui.Panel; +import com.vaadin.ui.TextArea; +import com.vaadin.ui.themes.ValoTheme; +import com.validation.manager.core.DataBaseManager; +import com.validation.manager.core.VMUI; +import com.validation.manager.core.db.TestCaseExecution; +import com.validation.manager.core.db.controller.TestCaseExecutionJpaController; +import com.validation.manager.core.db.controller.exceptions.NonexistentEntityException; +import com.validation.manager.core.server.core.TestCaseExecutionServer; +import com.validation.manager.core.server.core.TestCaseServer; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; +import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; +import net.sourceforge.javydreamercsw.validation.manager.web.component.ByteToStringConverter; +import org.vaadin.teemu.wizards.WizardStep; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class DetailStep implements WizardStep { + + private List testCases; + private final TestCaseExecution tce; + private static final Logger LOG + = Logger.getLogger(DetailStep.class.getSimpleName()); + + public DetailStep() { + this.tce = new TestCaseExecution(); + } + + @Override + public String getCaption() { + return "add.details"; + } + + @Override + public Component getContent() { + Panel form = new Panel("execution.detail"); + FormLayout layout = new FormLayout(); + form.setContent(layout); + form.addStyleName(ValoTheme.FORMLAYOUT_LIGHT); + BeanFieldGroup binder = new BeanFieldGroup(TestCaseExecution.class); + binder.setItemDataSource(tce); + TextArea name = new TextArea("general.name"); + name.setConverter(new ByteToStringConverter()); + binder.bind(name, "name"); + layout.addComponent(name); + TextArea scope = new TextArea("general.scope"); + scope.setConverter(new ByteToStringConverter()); + binder.bind(scope, "scope"); + layout.addComponent(scope); + if (tce.getId() != null) { + TextArea conclusion = new TextArea("general.conclusion"); + conclusion.setConverter(new ByteToStringConverter()); + binder.bind(conclusion, "conclusion"); + layout.addComponent(conclusion); + conclusion.setSizeFull(); + layout.addComponent(conclusion); + } + binder.setBuffered(false); + binder.bindMemberFields(form); + form.setSizeFull(); + return form; + } + + @Override + public boolean onAdvance() { + try { + //Create the record + new TestCaseExecutionJpaController(DataBaseManager + .getEntityManagerFactory()).create(tce); + TestCaseExecutionServer tces = new TestCaseExecutionServer(tce); + //Now create the execution records + TestCaseServer tc; + for (Integer id : testCases) { + //Retrieve the TestCase to get the steps + tc = new TestCaseServer(id); + tces.addTestCase(tc.getEntity()); + } + try { + tces.write2DB(); + VMUI ui = ValidationManagerUI.getInstance(); + ui.buildProjectTree(ui.getSelectdValue()); + ui.updateProjectList(); + ui.updateScreen(); + ui.displayObject(tces.getEntity(), false); + return true; + } catch (NonexistentEntityException ex) { + LOG.log(Level.SEVERE, null, ex); + } catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + } + } catch (Exception ex) { + LOG.log(Level.SEVERE, null, ex); + } + return false; + } + + @Override + public boolean onBack() { + return true; + } + + /** + * @return the testCases + */ + public List getTestCases() { + return testCases; + } + + /** + * @param testCases the testCases to set + */ + public void setTestCases(List testCases) { + this.testCases = testCases; + } +} diff --git a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/plan/SelectTestCasesStep.java b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/plan/SelectTestCasesStep.java index 54f95a96..b04cfca5 100644 --- a/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/plan/SelectTestCasesStep.java +++ b/Validation-Manager-Web/src/main/java/net/sourceforge/javydreamercsw/validation/manager/web/wizard/plan/SelectTestCasesStep.java @@ -13,198 +13,198 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package net.sourceforge.javydreamercsw.validation.manager.web.wizard.plan; - -import com.vaadin.data.Item; -import com.vaadin.ui.Component; -import com.vaadin.ui.HorizontalLayout; -import com.vaadin.ui.Notification; -import com.vaadin.ui.TreeTable; -import com.vaadin.ui.VerticalLayout; -import com.validation.manager.core.db.Project; -import java.util.ArrayList; -import java.util.List; -import java.util.logging.Level; -import java.util.logging.Logger; -import net.sourceforge.javydreamercsw.validation.manager.web.TreeTableCheckBox; -import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; -import org.vaadin.teemu.wizards.Wizard; -import org.vaadin.teemu.wizards.WizardStep; - -/** - * - * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com - */ -public class SelectTestCasesStep implements WizardStep { - - private final Project p; - private final Wizard w; - private final TreeTable testTree = new TreeTable("available.tests"); - private final List projects = new ArrayList<>(); - private static final Logger LOG - = Logger.getLogger(SelectTestCasesStep.class.getSimpleName()); - - public SelectTestCasesStep(Wizard w, Project p) { - this.p = p; - this.w = w; - } - - @Override - public String getCaption() { - return "select.test.case"; - } - - @Override - public Component getContent() { - VerticalLayout l = new VerticalLayout(); - //Add menu - HorizontalLayout menu = new HorizontalLayout(); - if (p != null) { - //Show the Test Plans for the selected project (including sub projects - testTree.addContainerProperty("general.name", - TreeTableCheckBox.class, ""); - testTree.addContainerProperty("general.description", - String.class, ""); - testTree.setWidth("20em"); - addProjectTestPlanning(testTree, p); - } - testTree.setSizeFull(); - l.addComponent(menu); - l.addComponent(testTree); - return l; - } - - @Override - public boolean onAdvance() { - //Get a list of selected test cases - List testCases - = processChildren("project" + p.getId()); - testCases.forEach((i) -> { - LOG.log(Level.FINE, "Test Case: {0}", i); - }); - if (testCases.isEmpty()) { - Notification.show("unable.to.proceed", - "select.test.case.message", - Notification.Type.WARNING_MESSAGE); - return false; - } - //update next step - DetailStep next = ((DetailStep) w.getSteps().get(1)); - next.setTestCases(testCases); - return true; - } - - @Override - public boolean onBack() { - return false; - } - - private void addProjectTestPlanning(TreeTable testTree, Project p) { - //Add the test projects - testTree.addItem(new Object[]{new TreeTableCheckBox(testTree, - p.getName(), "project" + p.getId()), ""}, - "project" + p.getId()); - if (p.getParentProjectId() != null) { - //Add as child - testTree.setParent("project" + p.getId(), - "project" + p.getParentProjectId().getId()); - } - p.getTestProjectList().stream().map((tp) -> { - TreeTableCheckBox cb = new TreeTableCheckBox(testTree, - tp.getName(), "testproject" + tp.getId()); - cb.setIcon(ValidationManagerUI.TEST_SUITE_ICON); - testTree.addItem(new Object[]{cb, ""}, - "testproject" + tp.getId()); - return tp; - }).map((tp) -> { - testTree.setParent("testproject" + tp.getId(), - "project" + p.getId()); - return tp; - }).map((tp) -> { - tp.getTestPlanList().stream().map((plan) -> { - TreeTableCheckBox pcb = new TreeTableCheckBox(testTree, - plan.getName(), plan.getTestPlanPK()); - pcb.setIcon(ValidationManagerUI.PLAN_ICON); - testTree.addItem(new Object[]{pcb, ""}, - plan.getTestPlanPK()); - return plan; - }).map((plan) -> { - testTree.setParent(plan.getTestPlanPK(), - "testproject" + tp.getId()); - return plan; - }).forEachOrdered((plan) -> { - plan.getTestCaseList().stream().map((tc) -> { - TreeTableCheckBox tccb = new TreeTableCheckBox(testTree, - tc.getName(), "tc" + tc.getId()); - tccb.setIcon(ValidationManagerUI.TEST_ICON); - testTree.addItem(new Object[]{tccb, - tc.getSummary() != null - ? new String(tc.getSummary()) : ""}, - "tc" + tc.getId()); - return tc; - }).map((tc) -> { - testTree.setParent("tc" + tc.getId(), - plan.getTestPlanPK()); - return tc; - }).forEachOrdered((tc) -> { - testTree.setChildrenAllowed("tc" + tc.getId(), false); - }); - }); - return tp; - }).forEachOrdered((tp) -> { - testTree.setCollapsed("testproject" + tp.getId(), false); - }); - p.getProjectList().forEach((sp) -> { - addProjectTestPlanning(testTree, sp); - }); - testTree.setCollapsed("project" + p.getId(), false); - } - - private List processChildren(Object parent) { - List testCases = new ArrayList<>(); - //Get a list of selected test cases - testTree.getChildren(parent).stream().map((o) -> { - if (o instanceof String) { - String id = (String) o; - if (id.startsWith("tc")) { - //Is a Test Case - Item item = testTree.getItem(id); - Object val = item.getItemProperty("general.name").getValue(); - if (val instanceof TreeTableCheckBox) { - TreeTableCheckBox ttcb = (TreeTableCheckBox) val; - if (ttcb.getValue()) { - //Selected - LOG.log(Level.FINE, "Included TC: {0}", - ttcb.getObjectId()); - testCases.add(Integer.parseInt(id.substring(2))); - Object pid = id; - //Add the related project to the list. - while (pid != null) { - if (pid instanceof String) { - String s = (String) pid; - if (s.startsWith("project")) { - LOG.log(Level.FINE, "Processing: {0}", s); - getProjects().add(Integer.parseInt(s.substring(7))); - break; - } - } - pid = testTree.getParent(pid); - } - } - } - } - } - return o; - }).filter((o) -> (testTree.hasChildren(o))).forEachOrdered((o) -> { - testCases.addAll(processChildren(o)); - }); - return testCases; - } - - /** - * @return the projects - */ - public List getProjects() { - return projects; - } -} +package net.sourceforge.javydreamercsw.validation.manager.web.wizard.plan; + +import com.vaadin.data.Item; +import com.vaadin.ui.Component; +import com.vaadin.ui.HorizontalLayout; +import com.vaadin.ui.Notification; +import com.vaadin.ui.TreeTable; +import com.vaadin.ui.VerticalLayout; +import com.validation.manager.core.db.Project; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; +import net.sourceforge.javydreamercsw.validation.manager.web.component.TreeTableCheckBox; +import net.sourceforge.javydreamercsw.validation.manager.web.ValidationManagerUI; +import org.vaadin.teemu.wizards.Wizard; +import org.vaadin.teemu.wizards.WizardStep; + +/** + * + * @author Javier A. Ortiz Bultron javier.ortiz.78@gmail.com + */ +public class SelectTestCasesStep implements WizardStep { + + private final Project p; + private final Wizard w; + private final TreeTable testTree = new TreeTable("available.tests"); + private final List projects = new ArrayList<>(); + private static final Logger LOG + = Logger.getLogger(SelectTestCasesStep.class.getSimpleName()); + + public SelectTestCasesStep(Wizard w, Project p) { + this.p = p; + this.w = w; + } + + @Override + public String getCaption() { + return "select.test.case"; + } + + @Override + public Component getContent() { + VerticalLayout l = new VerticalLayout(); + //Add menu + HorizontalLayout menu = new HorizontalLayout(); + if (p != null) { + //Show the Test Plans for the selected project (including sub projects + testTree.addContainerProperty("general.name", + TreeTableCheckBox.class, ""); + testTree.addContainerProperty("general.description", + String.class, ""); + testTree.setWidth("20em"); + addProjectTestPlanning(testTree, p); + } + testTree.setSizeFull(); + l.addComponent(menu); + l.addComponent(testTree); + return l; + } + + @Override + public boolean onAdvance() { + //Get a list of selected test cases + List testCases + = processChildren("project" + p.getId()); + testCases.forEach((i) -> { + LOG.log(Level.FINE, "Test Case: {0}", i); + }); + if (testCases.isEmpty()) { + Notification.show("unable.to.proceed", + "select.test.case.message", + Notification.Type.WARNING_MESSAGE); + return false; + } + //update next step + DetailStep next = ((DetailStep) w.getSteps().get(1)); + next.setTestCases(testCases); + return true; + } + + @Override + public boolean onBack() { + return false; + } + + private void addProjectTestPlanning(TreeTable testTree, Project p) { + //Add the test projects + testTree.addItem(new Object[]{new TreeTableCheckBox(testTree, + p.getName(), "project" + p.getId()), ""}, + "project" + p.getId()); + if (p.getParentProjectId() != null) { + //Add as child + testTree.setParent("project" + p.getId(), + "project" + p.getParentProjectId().getId()); + } + p.getTestProjectList().stream().map((tp) -> { + TreeTableCheckBox cb = new TreeTableCheckBox(testTree, + tp.getName(), "testproject" + tp.getId()); + cb.setIcon(ValidationManagerUI.TEST_SUITE_ICON); + testTree.addItem(new Object[]{cb, ""}, + "testproject" + tp.getId()); + return tp; + }).map((tp) -> { + testTree.setParent("testproject" + tp.getId(), + "project" + p.getId()); + return tp; + }).map((tp) -> { + tp.getTestPlanList().stream().map((plan) -> { + TreeTableCheckBox pcb = new TreeTableCheckBox(testTree, + plan.getName(), plan.getTestPlanPK()); + pcb.setIcon(ValidationManagerUI.PLAN_ICON); + testTree.addItem(new Object[]{pcb, ""}, + plan.getTestPlanPK()); + return plan; + }).map((plan) -> { + testTree.setParent(plan.getTestPlanPK(), + "testproject" + tp.getId()); + return plan; + }).forEachOrdered((plan) -> { + plan.getTestCaseList().stream().map((tc) -> { + TreeTableCheckBox tccb = new TreeTableCheckBox(testTree, + tc.getName(), "tc" + tc.getId()); + tccb.setIcon(ValidationManagerUI.TEST_ICON); + testTree.addItem(new Object[]{tccb, + tc.getSummary() != null + ? new String(tc.getSummary()) : ""}, + "tc" + tc.getId()); + return tc; + }).map((tc) -> { + testTree.setParent("tc" + tc.getId(), + plan.getTestPlanPK()); + return tc; + }).forEachOrdered((tc) -> { + testTree.setChildrenAllowed("tc" + tc.getId(), false); + }); + }); + return tp; + }).forEachOrdered((tp) -> { + testTree.setCollapsed("testproject" + tp.getId(), false); + }); + p.getProjectList().forEach((sp) -> { + addProjectTestPlanning(testTree, sp); + }); + testTree.setCollapsed("project" + p.getId(), false); + } + + private List processChildren(Object parent) { + List testCases = new ArrayList<>(); + //Get a list of selected test cases + testTree.getChildren(parent).stream().map((o) -> { + if (o instanceof String) { + String id = (String) o; + if (id.startsWith("tc")) { + //Is a Test Case + Item item = testTree.getItem(id); + Object val = item.getItemProperty("general.name").getValue(); + if (val instanceof TreeTableCheckBox) { + TreeTableCheckBox ttcb = (TreeTableCheckBox) val; + if (ttcb.getValue()) { + //Selected + LOG.log(Level.FINE, "Included TC: {0}", + ttcb.getObjectId()); + testCases.add(Integer.parseInt(id.substring(2))); + Object pid = id; + //Add the related project to the list. + while (pid != null) { + if (pid instanceof String) { + String s = (String) pid; + if (s.startsWith("project")) { + LOG.log(Level.FINE, "Processing: {0}", s); + getProjects().add(Integer.parseInt(s.substring(7))); + break; + } + } + pid = testTree.getParent(pid); + } + } + } + } + } + return o; + }).filter((o) -> (testTree.hasChildren(o))).forEachOrdered((o) -> { + testCases.addAll(processChildren(o)); + }); + return testCases; + } + + /** + * @return the projects + */ + public List getProjects() { + return projects; + } +} diff --git a/pom.xml b/pom.xml index 124264d9..e6c960e2 100644 --- a/pom.xml +++ b/pom.xml @@ -3,7 +3,7 @@ 4.0.0 Validation-Manager - 0.3.2 + 0.3.3 net.sourceforge.javydreamercsw pom @@ -176,24 +176,6 @@ false - - cy.github - github-release-plugin - 0.5.2 - - - ${project.artifactId}-${project.version} - true - - - - - gh-upload - - deploy - - -