JDBCConfigurazioneFiltroService.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it).
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */
  20. package org.openspcoop2.core.plugins.dao.jdbc;

  22. import org.openspcoop2.generic_project.dao.jdbc.IJDBCServiceCRUDWithId;
  23. import org.openspcoop2.core.plugins.IdConfigurazioneFiltro;

  25. import org.openspcoop2.generic_project.beans.NonNegativeNumber;
  26. import org.openspcoop2.generic_project.beans.UpdateField;
  27. import org.openspcoop2.generic_project.beans.UpdateModel;
  28. import org.openspcoop2.generic_project.dao.jdbc.JDBCProperties;
  29. import org.openspcoop2.generic_project.exception.NotFoundException;
  30. import org.openspcoop2.generic_project.exception.NotImplementedException;
  31. import org.openspcoop2.generic_project.exception.ServiceException;
  32. import org.openspcoop2.generic_project.exception.ValidationException;
  33. import org.openspcoop2.generic_project.expression.IExpression;
  34. import org.openspcoop2.generic_project.dao.jdbc.JDBCExpression;

  36. import org.openspcoop2.core.plugins.ConfigurazioneFiltro;
  37. import org.openspcoop2.core.plugins.dao.IDBConfigurazioneFiltroService;
  38. import org.openspcoop2.core.plugins.utils.ProjectInfo;

  40. import java.sql.Connection;

  42. import org.openspcoop2.utils.sql.ISQLQueryObject;

  44. /**     
  45.  * Service can be used to search for and manage the backend objects of type {@link org.openspcoop2.core.plugins.ConfigurazioneFiltro} 
  46.  *
  47.  * @author Poli Andrea (poli@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */

  52. public class JDBCConfigurazioneFiltroService extends JDBCConfigurazioneFiltroServiceSearch  implements IDBConfigurazioneFiltroService {


  55.     private IJDBCServiceCRUDWithId<ConfigurazioneFiltro, IdConfigurazioneFiltro, JDBCServiceManager> serviceCRUD = null;
  56.     public JDBCConfigurazioneFiltroService(JDBCServiceManager jdbcServiceManager) throws ServiceException {
  57.         super(jdbcServiceManager);
  58.         String msgInit = JDBCConfigurazioneFiltroService.class.getName()+ " initialized";
  59.         this.log.debug(msgInit);
  60.         this.serviceCRUD = JDBCProperties.getInstance(org.openspcoop2.core.plugins.dao.jdbc.JDBCServiceManager.class.getPackage(),ProjectInfo.getInstance()).getServiceCRUD("configurazioneFiltro");
  61.         this.serviceCRUD.setServiceManager(new JDBCLimitedServiceManager(this.jdbcServiceManager));
  62.     }

  64.     private static final String PARAMETER_TYPE_PREFIX = "Parameter (type:";
  65.     private ServiceException newServiceExceptionParameterIsNull(){
  66.         return new ServiceException(PARAMETER_TYPE_PREFIX+ConfigurazioneFiltro.class.getName()+") 'configurazioneFiltro' is null");
  67.     }
  68.     private ServiceException newServiceExceptionParameterIsLessEqualsZero(){
  69.         return new ServiceException(PARAMETER_TYPE_PREFIX+long.class.getName()+") 'tableId' is less equals 0");
  70.     }
  71.     private ServiceException newServiceExceptionParameterUpdateFieldsIsNull(){
  72.         return new ServiceException(PARAMETER_TYPE_PREFIX+UpdateField.class.getName()+") 'updateFields' is null");
  73.     }
  74.     private ServiceException newServiceExceptionParameterOldIdIsNull(){
  75.         return new ServiceException(PARAMETER_TYPE_PREFIX+IdConfigurazioneFiltro.class.getName()+") 'oldId' is null");
  76.     }
  77.     private ServiceException newServiceExceptionParameterConditionIsNull(){
  78.         return new ServiceException(PARAMETER_TYPE_PREFIX+IExpression.class.getName()+") 'condition' is null");
  79.     }
  80.     private ServiceException newServiceExceptionParameterUpdateModelsIsNull(){
  81.         return new ServiceException(PARAMETER_TYPE_PREFIX+UpdateModel.class.getName()+") 'updateModels' is null");
  82.     }
  83.     
  84.     private ServiceException newServiceExceptionUpdateFieldsNotCompleted(Exception e){
  85.         return new ServiceException("UpdateFields not completed: "+e.getMessage(),e);
  86.     }
  87.     
  88.     
  89.     private void releaseResources(boolean rollback, Connection connection, boolean oldValueAutoCommit) throws ServiceException {
  90.         if(this.jdbcProperties.isAutomaticTransactionManagement()){
  91.             manageTransaction(rollback, connection);
  92.             try{
  93.                 if(connection!=null)
  94.                     connection.setAutoCommit(oldValueAutoCommit);
  95.             }catch(Exception eIgnore){
  96.                 // ignore
  97.             }
  98.         }
  99.         if(connection!=null){
  100.             this.jdbcServiceManager.closeConnection(connection);
  101.         }
  102.     }
  103.     private void manageTransaction(boolean rollback, Connection connection) {
  104.         if(rollback){
  105.             try{
  106.                 if(connection!=null)
  107.                     connection.rollback();
  108.             }catch(Exception eIgnore){
  109.                 // ignore
  110.             }
  111.         }else{
  112.             try{
  113.                 if(connection!=null)
  114.                     connection.commit();
  115.             }catch(Exception eIgnore){
  116.                 // ignore
  117.             }
  118.         }
  119.     }
  120.     
  121.     
  122.     
  123.     @Override
  124.     public void create(ConfigurazioneFiltro configurazioneFiltro) throws ServiceException, NotImplementedException {
  125.         try{
  126.             this.create(configurazioneFiltro, false, null);
  127.         }catch(ValidationException vE){
  128.             // not possible
  129.             throw new ServiceException(vE.getMessage(), vE);
  130.         }
  131.     }
  132.     
  133.     @Override
  134.     public void create(ConfigurazioneFiltro configurazioneFiltro, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws ServiceException, NotImplementedException {
  135.         try{
  136.             this.create(configurazioneFiltro, false, idMappingResolutionBehaviour);
  137.         }catch(ValidationException vE){
  138.             // not possible
  139.             throw new ServiceException(vE.getMessage(), vE);
  140.         }
  141.     }
  142.     
  143.     @Override
  144.     public void create(ConfigurazioneFiltro configurazioneFiltro, boolean validate) throws ServiceException, NotImplementedException, ValidationException {
  145.         this.create(configurazioneFiltro, validate, null);
  146.     }
  147.     
  148.     @Override
  149.     public void create(ConfigurazioneFiltro configurazioneFiltro, boolean validate, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws ServiceException, NotImplementedException, ValidationException {
  150.         
  151.         Connection connection = null;
  152.         boolean oldValueAutoCommit = false;
  153.         boolean rollback = false;
  154.         try{
  155.             
  156.             // check parameters
  157.             if(configurazioneFiltro==null){
  158.                 throw this.newServiceExceptionParameterIsNull();
  159.             }
  160.             
  161.             // validate
  162.             if(validate){
  163.                 this.validate(configurazioneFiltro);
  164.             }

  166.             // ISQLQueryObject
  167.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  168.             sqlQueryObject.setANDLogicOperator(true);
  169.             // Connection sql
  170.             connection = this.jdbcServiceManager.getConnection();
  171.     
  172.             // transaction
  173.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  174.                 oldValueAutoCommit = connection.getAutoCommit();
  175.                 connection.setAutoCommit(false);
  176.             }
  177.         
  178.             this.serviceCRUD.create(this.jdbcProperties,this.log,connection,sqlQueryObject,configurazioneFiltro,idMappingResolutionBehaviour);          

  180.         }catch(ServiceException | NotImplementedException | ValidationException e){
  181.             rollback = true;
  182.             this.logError(e); throw e;
  183.         }catch(Exception e){
  184.             rollback = true;
  185.             this.logError(e); throw new ServiceException("Create not completed: "+e.getMessage(),e);
  186.         }finally{
  187.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  188.         }

  190.     }

  192.     @Override
  193.     public void update(IdConfigurazioneFiltro oldId, ConfigurazioneFiltro configurazioneFiltro) throws ServiceException, NotFoundException, NotImplementedException {
  194.         try{
  195.             this.update(oldId, configurazioneFiltro, false, null);
  196.         }catch(ValidationException vE){
  197.             // not possible
  198.             throw new ServiceException(vE.getMessage(), vE);
  199.         }
  200.     }
  201.     
  202.     @Override
  203.     public void update(IdConfigurazioneFiltro oldId, ConfigurazioneFiltro configurazioneFiltro, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws ServiceException, NotFoundException, NotImplementedException {
  204.         try{
  205.             this.update(oldId, configurazioneFiltro, false, idMappingResolutionBehaviour);
  206.         }catch(ValidationException vE){
  207.             // not possible
  208.             throw new ServiceException(vE.getMessage(), vE);
  209.         }
  210.     }
  211.     
  212.     @Override
  213.     public void update(IdConfigurazioneFiltro oldId, ConfigurazioneFiltro configurazioneFiltro, boolean validate) throws ServiceException, NotFoundException, NotImplementedException, ValidationException {
  214.         this.update(oldId, configurazioneFiltro, validate, null);
  215.     }
  216.         
  217.     @Override
  218.     public void update(IdConfigurazioneFiltro oldId, ConfigurazioneFiltro configurazioneFiltro, boolean validate, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws ServiceException, NotFoundException, NotImplementedException, ValidationException {
  219.     
  220.         Connection connection = null;
  221.         boolean oldValueAutoCommit = false;
  222.         boolean rollback = false;
  223.         try{
  224.             
  225.             // check parameters
  226.             if(configurazioneFiltro==null){
  227.                 throw this.newServiceExceptionParameterIsNull();
  228.             }
  229.             if(oldId==null){
  230.                 throw this.newServiceExceptionParameterOldIdIsNull();
  231.             }

  233.             // validate
  234.             if(validate){
  235.                 this.validate(configurazioneFiltro);
  236.             }

  238.             // ISQLQueryObject
  239.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  240.             sqlQueryObject.setANDLogicOperator(true);
  241.             // Connection sql
  242.             connection = this.jdbcServiceManager.getConnection();
  243.         
  244.             // transaction
  245.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  246.                 oldValueAutoCommit = connection.getAutoCommit();
  247.                 connection.setAutoCommit(false);
  248.             }

  250.             this.serviceCRUD.update(this.jdbcProperties,this.log,connection,sqlQueryObject,oldId,configurazioneFiltro,idMappingResolutionBehaviour);
  251.             
  252.         }catch(ServiceException | NotImplementedException | ValidationException e){
  253.             rollback = true;
  254.             this.logError(e); throw e;
  255.         }catch(NotFoundException e){
  256.             rollback = true;
  257.             this.logDebug(e); throw e;
  258.         }catch(Exception e){
  259.             rollback = true;
  260.             this.logError(e); throw new ServiceException("Update not completed: "+e.getMessage(),e);
  261.         }finally{
  262.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  263.         }

  265.     }
  266.     
  267.     @Override
  268.     public void update(long tableId, ConfigurazioneFiltro configurazioneFiltro) throws ServiceException, NotFoundException, NotImplementedException {
  269.         try{
  270.             this.update(tableId, configurazioneFiltro, false, null);
  271.         }catch(ValidationException vE){
  272.             // not possible
  273.             throw new ServiceException(vE.getMessage(), vE);
  274.         }
  275.     }
  276.     
  277.     @Override
  278.     public void update(long tableId, ConfigurazioneFiltro configurazioneFiltro, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws ServiceException, NotFoundException, NotImplementedException {
  279.         try{
  280.             this.update(tableId, configurazioneFiltro, false, idMappingResolutionBehaviour);
  281.         }catch(ValidationException vE){
  282.             // not possible
  283.             throw new ServiceException(vE.getMessage(), vE);
  284.         }
  285.     }
  286.     
  287.     @Override
  288.     public void update(long tableId, ConfigurazioneFiltro configurazioneFiltro, boolean validate) throws ServiceException, NotFoundException, NotImplementedException, ValidationException {
  289.         this.update(tableId, configurazioneFiltro, validate, null);
  290.     }
  291.         
  292.     @Override
  293.     public void update(long tableId, ConfigurazioneFiltro configurazioneFiltro, boolean validate, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws ServiceException, NotFoundException, NotImplementedException, ValidationException {
  294.     
  295.         Connection connection = null;
  296.         boolean oldValueAutoCommit = false;
  297.         boolean rollback = false;
  298.         try{
  299.             
  300.             // check parameters
  301.             if(configurazioneFiltro==null){
  302.                 throw this.newServiceExceptionParameterIsNull();
  303.             }
  304.             if(tableId<=0){
  305.                 throw this.newServiceExceptionParameterIsLessEqualsZero();
  306.             }

  308.             // validate
  309.             if(validate){
  310.                 this.validate(configurazioneFiltro);
  311.             }

  313.             // ISQLQueryObject
  314.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  315.             sqlQueryObject.setANDLogicOperator(true);
  316.             // Connection sql
  317.             connection = this.jdbcServiceManager.getConnection();
  318.         
  319.             // transaction
  320.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  321.                 oldValueAutoCommit = connection.getAutoCommit();
  322.                 connection.setAutoCommit(false);
  323.             }

  325.             this.serviceCRUD.update(this.jdbcProperties,this.log,connection,sqlQueryObject,tableId,configurazioneFiltro,idMappingResolutionBehaviour);
  326.             
  327.         }catch(ServiceException | NotImplementedException | ValidationException e){
  328.             rollback = true;
  329.             this.logError(e); throw e;
  330.         }catch(NotFoundException e){
  331.             rollback = true;
  332.             this.logDebug(e); throw e;
  333.         }catch(Exception e){
  334.             rollback = true;
  335.             this.logError(e); throw new ServiceException("Update not completed: "+e.getMessage(),e);
  336.         }finally{
  337.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  338.         }

  340.     }
  341.     
  342.     @Override
  343.     public void updateFields(IdConfigurazioneFiltro id, UpdateField ... updateFields) throws ServiceException, NotFoundException, NotImplementedException {
  344.     
  345.         Connection connection = null;
  346.         boolean oldValueAutoCommit = false;
  347.         boolean rollback = false;
  348.         try{
  349.             
  350.             // check parameters
  351.             if(id==null){
  352.                 throw this.newServiceExceptionParameterIdIsNull();
  353.             }
  354.             if(updateFields==null){
  355.                 throw this.newServiceExceptionParameterUpdateFieldsIsNull();
  356.             }

  358.             // ISQLQueryObject
  359.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  360.             sqlQueryObject.setANDLogicOperator(true);
  361.             // Connection sql
  362.             connection = this.jdbcServiceManager.getConnection();
  363.         
  364.             // transaction
  365.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  366.                 oldValueAutoCommit = connection.getAutoCommit();
  367.                 connection.setAutoCommit(false);
  368.             }

  370.             this.serviceCRUD.updateFields(this.jdbcProperties,this.log,connection,sqlQueryObject,id,updateFields);
  371.             
  372.         }catch(ServiceException | NotImplementedException e){
  373.             rollback = true;
  374.             this.logError(e); throw e;
  375.         }catch(NotFoundException e){
  376.             rollback = true;
  377.             this.logDebug(e); throw e;
  378.         }catch(Exception e){
  379.             rollback = true;
  380.             this.logError(e); throw this.newServiceExceptionUpdateFieldsNotCompleted(e);
  381.         }finally{
  382.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  383.         }

  385.     }
  386.     
  387.     @Override
  388.     public void updateFields(IdConfigurazioneFiltro id, IExpression condition, UpdateField ... updateFields) throws ServiceException, NotFoundException, NotImplementedException {
  389.     
  390.         Connection connection = null;
  391.         boolean oldValueAutoCommit = false;
  392.         boolean rollback = false;
  393.         try{
  394.             
  395.             // check parameters
  396.             if(id==null){
  397.                 throw this.newServiceExceptionParameterIdIsNull();
  398.             }
  399.             if(condition==null){
  400.                 throw this.newServiceExceptionParameterConditionIsNull();
  401.             }
  402.             if(updateFields==null){
  403.                 throw this.newServiceExceptionParameterUpdateFieldsIsNull();
  404.             }

  406.             // ISQLQueryObject
  407.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  408.             sqlQueryObject.setANDLogicOperator(true);
  409.             // Connection sql
  410.             connection = this.jdbcServiceManager.getConnection();
  411.         
  412.             // transaction
  413.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  414.                 oldValueAutoCommit = connection.getAutoCommit();
  415.                 connection.setAutoCommit(false);
  416.             }

  418.             this.serviceCRUD.updateFields(this.jdbcProperties,this.log,connection,sqlQueryObject,id,condition,updateFields);
  419.             
  420.         }catch(ServiceException | NotImplementedException e){
  421.             rollback = true;
  422.             this.logError(e); throw e;
  423.         }catch(NotFoundException e){
  424.             rollback = true;
  425.             this.logDebug(e); throw e;
  426.         }catch(Exception e){
  427.             rollback = true;
  428.             this.logError(e); throw this.newServiceExceptionUpdateFieldsNotCompleted(e);
  429.         }finally{
  430.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  431.         }

  433.     }

  435.     @Override
  436.     public void updateFields(IdConfigurazioneFiltro id, UpdateModel ... updateModels) throws ServiceException, NotFoundException, NotImplementedException {
  437.     
  438.         Connection connection = null;
  439.         boolean oldValueAutoCommit = false;
  440.         boolean rollback = false;
  441.         try{
  442.             
  443.             // check parameters
  444.             if(id==null){
  445.                 throw this.newServiceExceptionParameterIdIsNull();
  446.             }
  447.             if(updateModels==null){
  448.                 throw this.newServiceExceptionParameterUpdateModelsIsNull();
  449.             }

  451.             // ISQLQueryObject
  452.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  453.             sqlQueryObject.setANDLogicOperator(true);
  454.             // Connection sql
  455.             connection = this.jdbcServiceManager.getConnection();
  456.         
  457.             // transaction
  458.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  459.                 oldValueAutoCommit = connection.getAutoCommit();
  460.                 connection.setAutoCommit(false);
  461.             }

  463.             this.serviceCRUD.updateFields(this.jdbcProperties,this.log,connection,sqlQueryObject,id,updateModels);
  464.             
  465.         }catch(ServiceException | NotImplementedException e){
  466.             rollback = true;
  467.             this.logError(e); throw e;
  468.         }catch(NotFoundException e){
  469.             rollback = true;
  470.             this.logDebug(e); throw e;
  471.         }catch(Exception e){
  472.             rollback = true;
  473.             this.logError(e); throw this.newServiceExceptionUpdateFieldsNotCompleted(e);
  474.         }finally{
  475.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  476.         }

  478.     }

  480.     @Override
  481.     public void updateFields(long tableId, UpdateField ... updateFields) throws ServiceException, NotFoundException, NotImplementedException {
  482.     
  483.         Connection connection = null;
  484.         boolean oldValueAutoCommit = false;
  485.         boolean rollback = false;
  486.         try{
  487.             
  488.             // check parameters
  489.             if(tableId<=0){
  490.                 throw this.newServiceExceptionParameterIsLessEqualsZero();
  491.             }
  492.             if(updateFields==null){
  493.                 throw this.newServiceExceptionParameterUpdateFieldsIsNull();
  494.             }

  496.             // ISQLQueryObject
  497.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  498.             sqlQueryObject.setANDLogicOperator(true);
  499.             // Connection sql
  500.             connection = this.jdbcServiceManager.getConnection();
  501.         
  502.             // transaction
  503.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  504.                 oldValueAutoCommit = connection.getAutoCommit();
  505.                 connection.setAutoCommit(false);
  506.             }

  508.             this.serviceCRUD.updateFields(this.jdbcProperties,this.log,connection,sqlQueryObject,tableId,updateFields); 
  509.             
  510.         }catch(ServiceException | NotImplementedException e){
  511.             rollback = true;
  512.             this.logError(e); throw e;
  513.         }catch(NotFoundException e){
  514.             rollback = true;
  515.             this.logDebug(e); throw e;
  516.         }catch(Exception e){
  517.             rollback = true;
  518.             this.logError(e); throw this.newServiceExceptionUpdateFieldsNotCompleted(e);
  519.         }finally{
  520.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  521.         }

  523.     }
  524.     
  525.     @Override
  526.     public void updateFields(long tableId, IExpression condition, UpdateField ... updateFields) throws ServiceException, NotFoundException, NotImplementedException {
  527.     
  528.         Connection connection = null;
  529.         boolean oldValueAutoCommit = false;
  530.         boolean rollback = false;
  531.         try{
  532.             
  533.             // check parameters
  534.             if(tableId<=0){
  535.                 throw this.newServiceExceptionParameterIsLessEqualsZero();
  536.             }
  537.             if(condition==null){
  538.                 throw this.newServiceExceptionParameterConditionIsNull();
  539.             }
  540.             if(updateFields==null){
  541.                 throw this.newServiceExceptionParameterUpdateFieldsIsNull();
  542.             }

  544.             // ISQLQueryObject
  545.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  546.             sqlQueryObject.setANDLogicOperator(true);
  547.             // Connection sql
  548.             connection = this.jdbcServiceManager.getConnection();
  549.         
  550.             // transaction
  551.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  552.                 oldValueAutoCommit = connection.getAutoCommit();
  553.                 connection.setAutoCommit(false);
  554.             }

  556.             this.serviceCRUD.updateFields(this.jdbcProperties,this.log,connection,sqlQueryObject,tableId,condition,updateFields);
  557.             
  558.         }catch(ServiceException | NotImplementedException e){
  559.             rollback = true;
  560.             this.logError(e); throw e;
  561.         }catch(NotFoundException e){
  562.             rollback = true;
  563.             this.logDebug(e); throw e;
  564.         }catch(Exception e){
  565.             rollback = true;
  566.             this.logError(e); throw this.newServiceExceptionUpdateFieldsNotCompleted(e);
  567.         }finally{
  568.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  569.         }

  571.     }

  573.     @Override
  574.     public void updateFields(long tableId, UpdateModel ... updateModels) throws ServiceException, NotFoundException, NotImplementedException {
  575.     
  576.         Connection connection = null;
  577.         boolean oldValueAutoCommit = false;
  578.         boolean rollback = false;
  579.         try{
  580.             
  581.             // check parameters
  582.             if(tableId<=0){
  583.                 throw this.newServiceExceptionParameterIsLessEqualsZero();
  584.             }
  585.             if(updateModels==null){
  586.                 throw this.newServiceExceptionParameterUpdateModelsIsNull();
  587.             }

  589.             // ISQLQueryObject
  590.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  591.             sqlQueryObject.setANDLogicOperator(true);
  592.             // Connection sql
  593.             connection = this.jdbcServiceManager.getConnection();
  594.         
  595.             // transaction
  596.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  597.                 oldValueAutoCommit = connection.getAutoCommit();
  598.                 connection.setAutoCommit(false);
  599.             }

  601.             this.serviceCRUD.updateFields(this.jdbcProperties,this.log,connection,sqlQueryObject,tableId,updateModels);
  602.             
  603.         }catch(ServiceException | NotImplementedException e){
  604.             rollback = true;
  605.             this.logError(e); throw e;
  606.         }catch(NotFoundException e){
  607.             rollback = true;
  608.             this.logDebug(e); throw e;
  609.         }catch(Exception e){
  610.             rollback = true;
  611.             this.logError(e); throw this.newServiceExceptionUpdateFieldsNotCompleted(e);
  612.         }finally{
  613.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  614.         }

  616.     }

  618.     @Override
  619.     public void updateOrCreate(IdConfigurazioneFiltro oldId, ConfigurazioneFiltro configurazioneFiltro) throws ServiceException, NotImplementedException {
  620.         try{
  621.             this.updateOrCreate(oldId, configurazioneFiltro, false, null);
  622.         }catch(ValidationException vE){
  623.             // not possible
  624.             throw new ServiceException(vE.getMessage(), vE);
  625.         }
  626.     }
  627.     
  628.     @Override
  629.     public void updateOrCreate(IdConfigurazioneFiltro oldId, ConfigurazioneFiltro configurazioneFiltro, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws ServiceException, NotImplementedException {
  630.         try{
  631.             this.updateOrCreate(oldId, configurazioneFiltro, false, idMappingResolutionBehaviour);
  632.         }catch(ValidationException vE){
  633.             // not possible
  634.             throw new ServiceException(vE.getMessage(), vE);
  635.         }
  636.     }

  638.     @Override
  639.     public void updateOrCreate(IdConfigurazioneFiltro oldId, ConfigurazioneFiltro configurazioneFiltro, boolean validate) throws ServiceException, NotImplementedException, ValidationException {
  640.         this.updateOrCreate(oldId, configurazioneFiltro, validate, null);
  641.     }

  643.     @Override
  644.     public void updateOrCreate(IdConfigurazioneFiltro oldId, ConfigurazioneFiltro configurazioneFiltro, boolean validate, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws ServiceException, NotImplementedException, ValidationException {
  645.     
  646.         Connection connection = null;
  647.         boolean oldValueAutoCommit = false;
  648.         boolean rollback = false;
  649.         try{
  650.             
  651.             // check parameters
  652.             if(configurazioneFiltro==null){
  653.                 throw this.newServiceExceptionParameterIsNull();
  654.             }
  655.             if(oldId==null){
  656.                 throw this.newServiceExceptionParameterOldIdIsNull();
  657.             }

  659.             // validate
  660.             if(validate){
  661.                 this.validate(configurazioneFiltro);
  662.             }

  664.             // ISQLQueryObject
  665.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  666.             sqlQueryObject.setANDLogicOperator(true);
  667.             // Connection sql
  668.             connection = this.jdbcServiceManager.getConnection();
  669.         
  670.             // transaction
  671.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  672.                 oldValueAutoCommit = connection.getAutoCommit();
  673.                 connection.setAutoCommit(false);
  674.             }

  676.             this.serviceCRUD.updateOrCreate(this.jdbcProperties,this.log,connection,sqlQueryObject,oldId,configurazioneFiltro,idMappingResolutionBehaviour);
  677.             
  678.         }catch(ServiceException | NotImplementedException | ValidationException e){
  679.             rollback = true;
  680.             this.logError(e); throw e;
  681.         }catch(Exception e){
  682.             rollback = true;
  683.             this.logError(e); throw new ServiceException("UpdateOrCreate not completed: "+e.getMessage(),e);
  684.         }finally{
  685.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  686.         }

  688.     }
  689.     
  690.     @Override
  691.     public void updateOrCreate(long tableId, ConfigurazioneFiltro configurazioneFiltro) throws ServiceException, NotImplementedException {
  692.         try{
  693.             this.updateOrCreate(tableId, configurazioneFiltro, false, null);
  694.         }catch(ValidationException vE){
  695.             // not possible
  696.             throw new ServiceException(vE.getMessage(), vE);
  697.         }
  698.     }
  699.     
  700.     @Override
  701.     public void updateOrCreate(long tableId, ConfigurazioneFiltro configurazioneFiltro, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws ServiceException, NotImplementedException {
  702.         try{
  703.             this.updateOrCreate(tableId, configurazioneFiltro, false, idMappingResolutionBehaviour);
  704.         }catch(ValidationException vE){
  705.             // not possible
  706.             throw new ServiceException(vE.getMessage(), vE);
  707.         }
  708.     }

  710.     @Override
  711.     public void updateOrCreate(long tableId, ConfigurazioneFiltro configurazioneFiltro, boolean validate) throws ServiceException, NotImplementedException, ValidationException {
  712.         this.updateOrCreate(tableId, configurazioneFiltro, validate, null);
  713.     }

  715.     @Override
  716.     public void updateOrCreate(long tableId, ConfigurazioneFiltro configurazioneFiltro, boolean validate, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws ServiceException, NotImplementedException, ValidationException {

  718.         Connection connection = null;
  719.         boolean oldValueAutoCommit = false;
  720.         boolean rollback = false;
  721.         try{
  722.             
  723.             // check parameters
  724.             if(configurazioneFiltro==null){
  725.                 throw this.newServiceExceptionParameterIsNull();
  726.             }
  727.             if(tableId<=0){
  728.                 throw this.newServiceExceptionParameterIsLessEqualsZero();
  729.             }

  731.             // validate
  732.             if(validate){
  733.                 this.validate(configurazioneFiltro);
  734.             }

  736.             // ISQLQueryObject
  737.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  738.             sqlQueryObject.setANDLogicOperator(true);
  739.             // Connection sql
  740.             connection = this.jdbcServiceManager.getConnection();
  741.         
  742.             // transaction
  743.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  744.                 oldValueAutoCommit = connection.getAutoCommit();
  745.                 connection.setAutoCommit(false);
  746.             }

  748.             this.serviceCRUD.updateOrCreate(this.jdbcProperties,this.log,connection,sqlQueryObject,tableId,configurazioneFiltro,idMappingResolutionBehaviour);

  750.         }catch(ServiceException | NotImplementedException | ValidationException e){
  751.             rollback = true;
  752.             this.logError(e); throw e;
  753.         }catch(Exception e){
  754.             rollback = true;
  755.             this.logError(e); throw new ServiceException("UpdateOrCreate not completed: "+e.getMessage(),e);
  756.         }finally{
  757.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  758.         }

  760.     }
  761.     
  762.     @Override
  763.     public void delete(ConfigurazioneFiltro configurazioneFiltro) throws ServiceException,NotImplementedException {
  764.         
  765.         Connection connection = null;
  766.         boolean oldValueAutoCommit = false;
  767.         boolean rollback = false;
  768.         try{
  769.             
  770.             // check parameters
  771.             if(configurazioneFiltro==null){
  772.                 throw this.newServiceExceptionParameterIsNull();
  773.             }

  775.             // ISQLQueryObject
  776.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  777.             sqlQueryObject.setANDLogicOperator(true);
  778.             // Connection sql
  779.             connection = this.jdbcServiceManager.getConnection();

  781.             // transaction
  782.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  783.                 oldValueAutoCommit = connection.getAutoCommit();
  784.                 connection.setAutoCommit(false);
  785.             }

  787.             this.serviceCRUD.delete(this.jdbcProperties,this.log,connection,sqlQueryObject,configurazioneFiltro);   

  789.         }catch(ServiceException | NotImplementedException e){
  790.             rollback = true;
  791.             this.logError(e); throw e;
  792.         }catch(Exception e){
  793.             rollback = true;
  794.             this.logError(e); throw new ServiceException("Delete not completed: "+e.getMessage(),e);
  795.         }finally{
  796.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  797.         }
  798.     
  799.     }
  800.     

  802.     @Override
  803.     public void deleteById(IdConfigurazioneFiltro id) throws ServiceException, NotImplementedException {

  805.         Connection connection = null;
  806.         boolean oldValueAutoCommit = false;
  807.         boolean rollback = false;
  808.         try{
  809.             
  810.             // check parameters
  811.             if(id==null){
  812.                 throw this.newServiceExceptionParameterIdIsNull();
  813.             }

  815.             // ISQLQueryObject
  816.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  817.             sqlQueryObject.setANDLogicOperator(true);
  818.             // Connection sql
  819.             connection = this.jdbcServiceManager.getConnection();

  821.             // transaction
  822.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  823.                 oldValueAutoCommit = connection.getAutoCommit();
  824.                 connection.setAutoCommit(false);
  825.             }

  827.             this.serviceCRUD.deleteById(this.jdbcProperties,this.log,connection,sqlQueryObject,id);         

  829.         }catch(ServiceException | NotImplementedException e){
  830.             rollback = true;
  831.             this.logError(e); throw e;
  832.         }catch(Exception e){
  833.             rollback = true;
  834.             this.logError(e); throw new ServiceException("DeleteById not completed: "+e.getMessage(),e);
  835.         }finally{
  836.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  837.         }

  839.     }

  841.     @Override
  842.     public NonNegativeNumber deleteAll() throws ServiceException, NotImplementedException {

  844.         Connection connection = null;
  845.         boolean oldValueAutoCommit = false;
  846.         boolean rollback = false;
  847.         try{

  849.             // ISQLQueryObject
  850.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  851.             sqlQueryObject.setANDLogicOperator(true);
  852.             // Connection sql
  853.             connection = this.jdbcServiceManager.getConnection();
  854.         
  855.             // transaction
  856.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  857.                 oldValueAutoCommit = connection.getAutoCommit();
  858.                 connection.setAutoCommit(false);
  859.             }

  861.             return this.serviceCRUD.deleteAll(this.jdbcProperties,this.log,connection,sqlQueryObject);  

  863.         }catch(ServiceException | NotImplementedException e){
  864.             rollback = true;
  865.             this.logError(e); throw e;
  866.         }catch(Exception e){
  867.             rollback = true;
  868.             this.logError(e); throw new ServiceException("DeleteAll not completed: "+e.getMessage(),e);
  869.         }finally{
  870.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  871.         }
  872.     
  873.     }

  875.     @Override
  876.     public NonNegativeNumber deleteAll(IExpression expression) throws ServiceException, NotImplementedException {
  877.         
  878.         Connection connection = null;
  879.         boolean oldValueAutoCommit = false;
  880.         boolean rollback = false;
  881.         try{
  882.             
  883.             // check parameters
  884.             if(expression==null){
  885.                 throw this.newServiceExceptionParameterExpressionIsNull();
  886.             }
  887.             if( ! (expression instanceof JDBCExpression) ){
  888.                 throw this.newServiceExceptionParameterExpressionWrongType(expression);
  889.             }
  890.             JDBCExpression jdbcExpression = (JDBCExpression) expression;
  891.             this.logJDBCExpression(jdbcExpression);
  892.         
  893.             // ISQLQueryObject
  894.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  895.             sqlQueryObject.setANDLogicOperator(true);
  896.             // Connection sql
  897.             connection = this.jdbcServiceManager.getConnection();

  899.             // transaction
  900.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  901.                 oldValueAutoCommit = connection.getAutoCommit();
  902.                 connection.setAutoCommit(false);
  903.             }

  905.             return this.serviceCRUD.deleteAll(this.jdbcProperties,this.log,connection,sqlQueryObject,jdbcExpression);
  906.     
  907.         }catch(ServiceException | NotImplementedException e){
  908.             rollback = true;
  909.             this.logError(e); throw e;
  910.         }catch(Exception e){
  911.             rollback = true;
  912.             this.logError(e); throw new ServiceException("DeleteAll(expression) not completed: "+e.getMessage(),e);
  913.         }finally{
  914.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  915.         }
  916.     
  917.     }
  918.     
  919.     // -- DB
  920.     
  921.     @Override
  922.     public void deleteById(long tableId) throws ServiceException, NotImplementedException {
  923.         
  924.         Connection connection = null;
  925.         boolean oldValueAutoCommit = false;
  926.         boolean rollback = false;
  927.         try{
  928.             
  929.             // check parameters
  930.             if(tableId<=0){
  931.                 throw new ServiceException("Parameter 'tableId' is less equals 0");
  932.             }
  933.         
  934.             // ISQLQueryObject
  935.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  936.             sqlQueryObject.setANDLogicOperator(true);
  937.             // Connection sql
  938.             connection = this.jdbcServiceManager.getConnection();

  940.             // transaction
  941.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  942.                 oldValueAutoCommit = connection.getAutoCommit();
  943.                 connection.setAutoCommit(false);
  944.             }

  946.             this.serviceCRUD.deleteById(this.jdbcProperties,this.log,connection,sqlQueryObject,tableId);
  947.     
  948.         }catch(ServiceException | NotImplementedException e){
  949.             rollback = true;
  950.             this.logError(e); throw e;
  951.         }catch(Exception e){
  952.             rollback = true;
  953.             this.logError(e); throw new ServiceException("DeleteById(tableId) not completed: "+e.getMessage(),e);
  954.         }finally{
  955.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  956.         }
  957.     
  958.     }
  959.     
  960.     @Override
  961.     public int nativeUpdate(String sql,Object ... param) throws ServiceException, NotImplementedException {
  962.         
  963.         Connection connection = null;
  964.         boolean oldValueAutoCommit = false;
  965.         boolean rollback = false;
  966.         try{
  967.             
  968.             // check parameters
  969.             if(sql==null){
  970.                 throw new ServiceException("Parameter 'sql' is null");
  971.             }
  972.         
  973.             // ISQLQueryObject
  974.             ISQLQueryObject sqlQueryObject = this.jdbcSqlObjectFactory.createSQLQueryObject(this.jdbcProperties.getDatabase());
  975.             sqlQueryObject.setANDLogicOperator(true);
  976.             // Connection sql
  977.             connection = this.jdbcServiceManager.getConnection();

  979.             // transaction
  980.             if(this.jdbcProperties.isAutomaticTransactionManagement()){
  981.                 oldValueAutoCommit = connection.getAutoCommit();
  982.                 connection.setAutoCommit(false);
  983.             }

  985.             return this.serviceCRUD.nativeUpdate(this.jdbcProperties,this.log,connection,sqlQueryObject,sql,param);
  986.     
  987.         }catch(ServiceException | NotImplementedException e){
  988.             rollback = true;
  989.             this.logError(e); throw e;
  990.         }catch(Exception e){
  991.             rollback = true;
  992.             this.logError(e); throw new ServiceException("DeleteById(tableId) not completed: "+e.getMessage(),e);
  993.         }finally{
  994.             this.releaseResources(rollback, connection, oldValueAutoCommit);
  995.         }
  996.     
  997.     }
  998.     
  999. }
Created with JaCoCo 0.8.8.202204050719