JDBCConfigurazioneServizioServiceSearchImpl.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 java.util.List;
  23. import java.util.ArrayList;
  24. import java.util.Map;

  26. import java.sql.Connection;

  28. import org.slf4j.Logger;

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

  32. import org.openspcoop2.generic_project.expression.impl.sql.ISQLFieldConverter;
  33. import org.openspcoop2.generic_project.dao.jdbc.utils.IJDBCFetch;
  34. import org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject;
  35. import org.openspcoop2.generic_project.dao.jdbc.IJDBCServiceSearchWithId;
  36. import org.openspcoop2.core.plugins.IdConfigurazioneServizio;
  37. import org.openspcoop2.generic_project.utils.UtilsTemplate;
  38. import org.openspcoop2.generic_project.beans.CustomField;
  39. import org.openspcoop2.generic_project.beans.InUse;
  40. import org.openspcoop2.generic_project.beans.IField;
  41. import org.openspcoop2.generic_project.beans.NonNegativeNumber;
  42. import org.openspcoop2.generic_project.beans.UnionExpression;
  43. import org.openspcoop2.generic_project.beans.Union;
  44. import org.openspcoop2.generic_project.beans.FunctionField;
  45. import org.openspcoop2.generic_project.exception.MultipleResultException;
  46. import org.openspcoop2.generic_project.exception.NotFoundException;
  47. import org.openspcoop2.generic_project.exception.NotImplementedException;
  48. import org.openspcoop2.generic_project.exception.ServiceException;
  49. import org.openspcoop2.generic_project.expression.IExpression;
  50. import org.openspcoop2.generic_project.dao.jdbc.JDBCExpression;
  51. import org.openspcoop2.generic_project.dao.jdbc.JDBCPaginatedExpression;

  53. import org.openspcoop2.generic_project.dao.jdbc.JDBCServiceManagerProperties;
  54. import org.openspcoop2.core.plugins.dao.jdbc.converter.ConfigurazioneServizioFieldConverter;
  55. import org.openspcoop2.core.plugins.dao.jdbc.fetch.ConfigurazioneServizioFetch;
  56. import org.openspcoop2.core.plugins.ConfigurazioneServizio;

  58. /**     
  59.  * JDBCConfigurazioneServizioServiceSearchImpl
  60.  *
  61.  * @author Poli Andrea (poli@link.it)
  62.  * @author $Author$
  63.  * @version $Rev$, $Date$
  64.  */
  65. public class JDBCConfigurazioneServizioServiceSearchImpl implements IJDBCServiceSearchWithId<ConfigurazioneServizio, IdConfigurazioneServizio, JDBCServiceManager> {

  67.     private ConfigurazioneServizioFieldConverter _configurazioneServizioFieldConverter = null;
  68.     public ConfigurazioneServizioFieldConverter getConfigurazioneServizioFieldConverter() {
  69.         if(this._configurazioneServizioFieldConverter==null){
  70.             this._configurazioneServizioFieldConverter = new ConfigurazioneServizioFieldConverter(this.jdbcServiceManager.getJdbcProperties().getDatabaseType());
  71.         }       
  72.         return this._configurazioneServizioFieldConverter;
  73.     }
  74.     @Override
  75.     public ISQLFieldConverter getFieldConverter() {
  76.         return this.getConfigurazioneServizioFieldConverter();
  77.     }
  78.     
  79.     private ConfigurazioneServizioFetch configurazioneServizioFetch = new ConfigurazioneServizioFetch();
  80.     public ConfigurazioneServizioFetch getConfigurazioneServizioFetch() {
  81.         return this.configurazioneServizioFetch;
  82.     }
  83.     @Override
  84.     public IJDBCFetch getFetch() {
  85.         return getConfigurazioneServizioFetch();
  86.     }
  87.     
  88.     
  89.     private JDBCServiceManager jdbcServiceManager = null;

  91.     @Override
  92.     public void setServiceManager(JDBCServiceManager serviceManager) throws ServiceException{
  93.         this.jdbcServiceManager = serviceManager;
  94.     }
  95.     
  96.     @Override
  97.     public JDBCServiceManager getServiceManager() throws ServiceException{
  98.         return this.jdbcServiceManager;
  99.     }
  100.     

  102.     @Override
  103.     public IdConfigurazioneServizio convertToId(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, ConfigurazioneServizio configurazioneServizio) throws NotImplementedException, ServiceException, Exception{
  104.     
  105.         IdConfigurazioneServizio idConfigurazioneServizio = new IdConfigurazioneServizio();
  106.         idConfigurazioneServizio.setAccordo(configurazioneServizio.getAccordo());
  107.         idConfigurazioneServizio.setTipoSoggettoReferente(configurazioneServizio.getTipoSoggettoReferente());
  108.         idConfigurazioneServizio.setNomeSoggettoReferente(configurazioneServizio.getNomeSoggettoReferente());
  109.         idConfigurazioneServizio.setVersione(configurazioneServizio.getVersione());
  110.         idConfigurazioneServizio.setServizio(configurazioneServizio.getServizio());
  111.         return idConfigurazioneServizio;

  113.     }
  114.     
  115.     @Override
  116.     public ConfigurazioneServizio get(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdConfigurazioneServizio id, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException,Exception {
  117.         Long id_configurazioneServizio = ( (id!=null && id.getId()!=null && id.getId()>0) ? id.getId() : this.findIdConfigurazioneServizio(jdbcProperties, log, connection, sqlQueryObject, id, true));
  118.         return this.getEngine(jdbcProperties, log, connection, sqlQueryObject, id_configurazioneServizio,idMappingResolutionBehaviour);
  119.         
  120.         
  121.     }
  122.     
  123.     @Override
  124.     public boolean exists(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdConfigurazioneServizio id) throws MultipleResultException, NotImplementedException, ServiceException,Exception {

  126.         Long id_configurazioneServizio = this.findIdConfigurazioneServizio(jdbcProperties, log, connection, sqlQueryObject, id, false);
  127.         return id_configurazioneServizio != null && id_configurazioneServizio > 0;
  128.         
  129.     }
  130.     
  131.     @Override
  132.     public List<IdConfigurazioneServizio> findAllIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCPaginatedExpression expression, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotImplementedException, ServiceException,Exception {

  134.         List<IdConfigurazioneServizio> list = new ArrayList<IdConfigurazioneServizio>();

  136.         // TODO: implementazione non efficiente. 
  137.         // Per ottenere una implementazione efficiente:
  138.         // 1. Usare metodo select di questa classe indirizzando esattamente i field necessari a create l'ID logico
  139.         // 2. Usare metodo getConfigurazioneServizioFetch() sul risultato della select per ottenere un oggetto ConfigurazioneServizio
  140.         //    La fetch con la map inserirà nell'oggetto solo i valori estratti 
  141.         // 3. Usare metodo convertToId per ottenere l'id

  143.         List<Long> ids = this.findAllTableIds(jdbcProperties, log, connection, sqlQueryObject, expression);
  144.         
  145.         for(Long id: ids) {
  146.             ConfigurazioneServizio configurazioneServizio = this.get(jdbcProperties, log, connection, sqlQueryObject, id, idMappingResolutionBehaviour);
  147.             IdConfigurazioneServizio idConfigurazioneServizio = this.convertToId(jdbcProperties,log,connection,sqlQueryObject,configurazioneServizio);
  148.             list.add(idConfigurazioneServizio);
  149.         }

  151.         return list;
  152.         
  153.     }
  154.     
  155.     @Override
  156.     public List<ConfigurazioneServizio> findAll(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCPaginatedExpression expression, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotImplementedException, ServiceException,Exception {

  158.         List<ConfigurazioneServizio> list = new ArrayList<ConfigurazioneServizio>();
  159.         
  160.         // TODO: implementazione non efficiente. 
  161.         // Per ottenere una implementazione efficiente:
  162.         // 1. Usare metodo select di questa classe indirizzando esattamente i field necessari
  163.         // 2. Usare metodo getConfigurazioneServizioFetch() sul risultato della select per ottenere un oggetto ConfigurazioneServizio
  164.         //    La fetch con la map inserirà nell'oggetto solo i valori estratti 

  166.         List<Long> ids = this.findAllTableIds(jdbcProperties, log, connection, sqlQueryObject, expression);
  167.         
  168.         for(Long id: ids) {
  169.             list.add(this.get(jdbcProperties, log, connection, sqlQueryObject, id, idMappingResolutionBehaviour));
  170.         }

  172.         return list;      
  173.         
  174.     }
  175.     
  176.     @Override
  177.     public ConfigurazioneServizio find(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) 
  178.         throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException,Exception {

  180.         long id = this.findTableId(jdbcProperties, log, connection, sqlQueryObject, expression);
  181.         if(id>0){
  182.             return this.get(jdbcProperties, log, connection, sqlQueryObject, id, idMappingResolutionBehaviour);
  183.         }else{
  184.             throw new NotFoundException("Entry with id["+id+"] not found");
  185.         }
  186.         
  187.     }
  188.     
  189.     @Override
  190.     public NonNegativeNumber count(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression) throws NotImplementedException, ServiceException,Exception {
  191.         
  192.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareCount(jdbcProperties, log, connection, sqlQueryObject, expression,
  193.                                                 this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model());
  194.         
  195.         sqlQueryObject.addSelectCountField(this.getConfigurazioneServizioFieldConverter().toTable(ConfigurazioneServizio.model())+".id","tot",true);
  196.         
  197.         joinEngine(expression,sqlQueryObject);
  198.         
  199.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.count(jdbcProperties, log, connection, sqlQueryObject, expression,
  200.                                                                             this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model(),listaQuery);
  201.     }

  203.     @Override
  204.     public InUse inUse(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdConfigurazioneServizio id) throws NotFoundException, NotImplementedException, ServiceException,Exception {
  205.         
  206.         Long id_configurazioneServizio = this.findIdConfigurazioneServizio(jdbcProperties, log, connection, sqlQueryObject, id, true);
  207.         return this.inUseEngine(jdbcProperties, log, connection, sqlQueryObject, id_configurazioneServizio);
  208.         
  209.     }

  211.     @Override
  212.     public List<Object> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  213.                                                     JDBCPaginatedExpression paginatedExpression, IField field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  214.         return this.select(jdbcProperties, log, connection, sqlQueryObject,
  215.                                 paginatedExpression, false, field);
  216.     }
  217.     
  218.     @Override
  219.     public List<Object> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  220.                                                     JDBCPaginatedExpression paginatedExpression, boolean distinct, IField field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  221.         List<Map<String,Object>> map = 
  222.             this.select(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression, distinct, new IField[]{field});
  223.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.selectSingleObject(map);
  224.     }
  225.     
  226.     @Override
  227.     public List<Map<String,Object>> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  228.                                                     JDBCPaginatedExpression paginatedExpression, IField ... field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  229.         return this.select(jdbcProperties, log, connection, sqlQueryObject,
  230.                                 paginatedExpression, false, field);
  231.     }
  232.     
  233.     @Override
  234.     public List<Map<String,Object>> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  235.                                                     JDBCPaginatedExpression paginatedExpression, boolean distinct, IField ... field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  236.         
  237.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,paginatedExpression,field);
  238.         try{
  239.         
  240.             ISQLQueryObject sqlQueryObjectDistinct = 
  241.                         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSqlQueryObjectForSelectDistinct(distinct,sqlQueryObject, paginatedExpression, log,
  242.                                                 this.getConfigurazioneServizioFieldConverter(), field);

  244.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression, sqlQueryObjectDistinct);
  245.             
  246.         }finally{
  247.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,paginatedExpression,field);
  248.         }
  249.     }

  251.     @Override
  252.     public Object aggregate(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  253.                                                     JDBCExpression expression, FunctionField functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  254.         Map<String,Object> map = 
  255.             this.aggregate(jdbcProperties, log, connection, sqlQueryObject, expression, new FunctionField[]{functionField});
  256.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.selectAggregateObject(map,functionField);
  257.     }
  258.     
  259.     @Override
  260.     public Map<String,Object> aggregate(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  261.                                                     JDBCExpression expression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {                                                   
  262.         
  263.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,expression,functionField);
  264.         try{
  265.             List<Map<String,Object>> list = selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression);
  266.             return list.get(0);
  267.         }finally{
  268.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,expression,functionField);
  269.         }
  270.     }

  272.     @Override
  273.     public List<Map<String,Object>> groupBy(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  274.                                                     JDBCExpression expression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  275.         
  276.         if(expression.getGroupByFields().isEmpty()){
  277.             throw new ServiceException("GroupBy conditions not found in expression");
  278.         }
  279.         
  280.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,expression,functionField);
  281.         try{
  282.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression);
  283.         }finally{
  284.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,expression,functionField);
  285.         }
  286.     }
  287.     

  289.     @Override
  290.     public List<Map<String,Object>> groupBy(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  291.                                                     JDBCPaginatedExpression paginatedExpression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  292.         
  293.         if(paginatedExpression.getGroupByFields().isEmpty()){
  294.             throw new ServiceException("GroupBy conditions not found in expression");
  295.         }
  296.         
  297.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,paginatedExpression,functionField);
  298.         try{
  299.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression);
  300.         }finally{
  301.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,paginatedExpression,functionField);
  302.         }
  303.     }
  304.     
  305.     protected List<Map<String,Object>> selectEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  306.                                                 IExpression expression) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  307.         return selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression, null);
  308.     }
  309.     protected List<Map<String,Object>> selectEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  310.                                                 IExpression expression, ISQLQueryObject sqlQueryObjectDistinct) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  311.         
  312.         List<Object> listaQuery = new ArrayList<>();
  313.         List<JDBCObject> listaParams = new ArrayList<>();
  314.         List<Object> returnField = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSelect(jdbcProperties, log, connection, sqlQueryObject, 
  315.                                 expression, this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model(), 
  316.                                 listaQuery,listaParams);
  317.         
  318.         joinEngine(expression,sqlQueryObject);
  319.         
  320.         List<Map<String,Object>> list = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.select(jdbcProperties, log, connection,
  321.                                         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSqlQueryObjectForSelectDistinct(sqlQueryObject,sqlQueryObjectDistinct), 
  322.                                         expression, this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model(),
  323.                                         listaQuery,listaParams,returnField);
  324.         if(list!=null && !list.isEmpty()){
  325.             return list;
  326.         }
  327.         else{
  328.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  329.         }
  330.     }
  331.     
  332.     @Override
  333.     public List<Map<String,Object>> union(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  334.                                                 Union union, UnionExpression ... unionExpression) throws ServiceException,NotFoundException,NotImplementedException,Exception {     
  335.         
  336.         List<ISQLQueryObject> sqlQueryObjectInnerList = new ArrayList<>();
  337.         List<JDBCObject> jdbcObjects = new ArrayList<>();
  338.         List<Class<?>> returnClassTypes = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareUnion(jdbcProperties, log, connection, sqlQueryObject, 
  339.                                 this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model(), 
  340.                                 sqlQueryObjectInnerList, jdbcObjects, union, unionExpression);
  341.         
  342.         if(unionExpression!=null){
  343.             for (int i = 0; i < unionExpression.length; i++) {
  344.                 UnionExpression ue = unionExpression[i];
  345.                 IExpression expression = ue.getExpression();
  346.                 joinEngine(expression,sqlQueryObjectInnerList.get(i));
  347.             }
  348.         }
  349.         
  350.         List<Map<String,Object>> list = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.union(jdbcProperties, log, connection, sqlQueryObject, 
  351.                                         this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model(), 
  352.                                         sqlQueryObjectInnerList, jdbcObjects, returnClassTypes, union, unionExpression);
  353.         if(list!=null && !list.isEmpty()){
  354.             return list;
  355.         }
  356.         else{
  357.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  358.         }                               
  359.     }
  360.     
  361.     @Override
  362.     public NonNegativeNumber unionCount(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  363.                                                 Union union, UnionExpression ... unionExpression) throws ServiceException,NotFoundException,NotImplementedException,Exception {     
  364.         
  365.         List<ISQLQueryObject> sqlQueryObjectInnerList = new ArrayList<>();
  366.         List<JDBCObject> jdbcObjects = new ArrayList<>();
  367.         List<Class<?>> returnClassTypes = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareUnionCount(jdbcProperties, log, connection, sqlQueryObject, 
  368.                                 this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model(), 
  369.                                 sqlQueryObjectInnerList, jdbcObjects, union, unionExpression);
  370.         
  371.         if(unionExpression!=null){
  372.             for (int i = 0; i < unionExpression.length; i++) {
  373.                 UnionExpression ue = unionExpression[i];
  374.                 IExpression expression = ue.getExpression();
  375.                 joinEngine(expression,sqlQueryObjectInnerList.get(i));
  376.             }
  377.         }
  378.         
  379.         NonNegativeNumber number = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.unionCount(jdbcProperties, log, connection, sqlQueryObject, 
  380.                                         this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model(), 
  381.                                         sqlQueryObjectInnerList, jdbcObjects, returnClassTypes, union, unionExpression);
  382.         if(number!=null && number.longValue()>=0){
  383.             return number;
  384.         }
  385.         else{
  386.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  387.         }
  388.     }



  392.     // -- ConstructorExpression 

  394.     @Override
  395.     public JDBCExpression newExpression(Logger log) throws NotImplementedException, ServiceException {
  396.         try{
  397.             return new JDBCExpression(this.getConfigurazioneServizioFieldConverter());
  398.         }catch(Exception e){
  399.             throw new ServiceException(e);
  400.         }
  401.     }


  404.     @Override
  405.     public JDBCPaginatedExpression newPaginatedExpression(Logger log) throws NotImplementedException, ServiceException {
  406.         try{
  407.             return new JDBCPaginatedExpression(this.getConfigurazioneServizioFieldConverter());
  408.         }catch(Exception e){
  409.             throw new ServiceException(e);
  410.         }
  411.     }
  412.     
  413.     @Override
  414.     public JDBCExpression toExpression(JDBCPaginatedExpression paginatedExpression, Logger log) throws NotImplementedException, ServiceException {
  415.         try{
  416.             return new JDBCExpression(paginatedExpression);
  417.         }catch(Exception e){
  418.             throw new ServiceException(e);
  419.         }
  420.     }

  422.     @Override
  423.     public JDBCPaginatedExpression toPaginatedExpression(JDBCExpression expression, Logger log) throws NotImplementedException, ServiceException {
  424.         try{
  425.             return new JDBCPaginatedExpression(expression);
  426.         }catch(Exception e){
  427.             throw new ServiceException(e);
  428.         }
  429.     }
  430.     
  431.     
  432.     
  433.     // -- DB

  435.     @Override
  436.     public void mappingTableIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdConfigurazioneServizio id, ConfigurazioneServizio obj) throws NotFoundException,NotImplementedException,ServiceException,Exception{
  437.         _mappingTableIds(jdbcProperties,log,connection,sqlQueryObject,obj,
  438.                 this.get(jdbcProperties,log,connection,sqlQueryObject,id,null));
  439.     }
  440.     
  441.     @Override
  442.     public void mappingTableIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId, ConfigurazioneServizio obj) throws NotFoundException,NotImplementedException,ServiceException,Exception{
  443.         _mappingTableIds(jdbcProperties,log,connection,sqlQueryObject,obj,
  444.                 this.get(jdbcProperties,log,connection,sqlQueryObject,tableId,null));
  445.     }
  446.     private void _mappingTableIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, ConfigurazioneServizio obj, ConfigurazioneServizio imgSaved) throws NotFoundException,NotImplementedException,ServiceException,Exception{
  447.         if(imgSaved==null){
  448.             return;
  449.         }
  450.         obj.setId(imgSaved.getId());
  451.         if(obj.getConfigurazioneServizioAzioneList()!=null){
  452.             List<org.openspcoop2.core.plugins.IdConfigurazioneServizioAzione> listObj_ = obj.getConfigurazioneServizioAzioneList();
  453.             for(org.openspcoop2.core.plugins.IdConfigurazioneServizioAzione itemObj_ : listObj_){
  454.                 org.openspcoop2.core.plugins.IdConfigurazioneServizioAzione itemAlreadySaved_ = null;
  455.                 if(imgSaved.getConfigurazioneServizioAzioneList()!=null){
  456.                     List<org.openspcoop2.core.plugins.IdConfigurazioneServizioAzione> listImgSaved_ = imgSaved.getConfigurazioneServizioAzioneList();
  457.                     for(org.openspcoop2.core.plugins.IdConfigurazioneServizioAzione itemImgSaved_ : listImgSaved_){
  458.                         boolean objEqualsToImgSaved_ = false;
  459.                         objEqualsToImgSaved_ = org.openspcoop2.generic_project.utils.Utilities.equals(itemObj_.getAzione(),itemImgSaved_.getAzione());
  460.                         if(objEqualsToImgSaved_){
  461.                             itemAlreadySaved_=itemImgSaved_;
  462.                             break;
  463.                         }
  464.                     }
  465.                 }
  466.                 if(itemAlreadySaved_!=null){
  467.                     itemObj_.setId(itemAlreadySaved_.getId());
  468.                     if(itemObj_.getIdConfigurazioneServizio()!=null && 
  469.                             itemAlreadySaved_.getIdConfigurazioneServizio()!=null){
  470.                         itemObj_.getIdConfigurazioneServizio().setId(itemAlreadySaved_.getIdConfigurazioneServizio().getId());
  471.                     }
  472.                 }
  473.             }
  474.         }
  475.              
  476.     }
  477.     
  478.     @Override
  479.     public ConfigurazioneServizio get(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException, Exception {
  480.         return this.getEngine(jdbcProperties, log, connection, sqlQueryObject, Long.valueOf(tableId), idMappingResolutionBehaviour);
  481.     }
  482.     
  483.     private ConfigurazioneServizio getEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, Long tableId, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException, Exception {
  484.     
  485.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  486.                     new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  487.         
  488.         ISQLQueryObject sqlQueryObjectGet = sqlQueryObject.newSQLQueryObject();
  489.                 
  490.         ConfigurazioneServizio configurazioneServizio = new ConfigurazioneServizio();
  491.         

  493.         // Object configurazioneServizio
  494.         ISQLQueryObject sqlQueryObjectGet_configurazioneServizio = sqlQueryObjectGet.newSQLQueryObject();
  495.         sqlQueryObjectGet_configurazioneServizio.setANDLogicOperator(true);
  496.         sqlQueryObjectGet_configurazioneServizio.addFromTable(this.getConfigurazioneServizioFieldConverter().toTable(ConfigurazioneServizio.model()));
  497.         sqlQueryObjectGet_configurazioneServizio.addSelectField("id");
  498.         sqlQueryObjectGet_configurazioneServizio.addSelectField(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().ACCORDO,true));
  499.         sqlQueryObjectGet_configurazioneServizio.addSelectField(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().TIPO_SOGGETTO_REFERENTE,true));
  500.         sqlQueryObjectGet_configurazioneServizio.addSelectField(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().NOME_SOGGETTO_REFERENTE,true));
  501.         sqlQueryObjectGet_configurazioneServizio.addSelectField(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().VERSIONE,true));
  502.         sqlQueryObjectGet_configurazioneServizio.addSelectField(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().SERVIZIO,true));
  503.         sqlQueryObjectGet_configurazioneServizio.addWhereCondition("id=?");

  505.         // Get configurazioneServizio
  506.         configurazioneServizio = (ConfigurazioneServizio) jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet_configurazioneServizio.createSQLQuery(), jdbcProperties.isShowSql(), ConfigurazioneServizio.model(), this.getConfigurazioneServizioFetch(),
  507.             new JDBCObject(tableId,Long.class));



  511.         
  512.         return configurazioneServizio;  
  513.     
  514.     } 
  515.     
  516.     @Override
  517.     public boolean exists(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId) throws MultipleResultException, NotImplementedException, ServiceException, Exception {
  518.         return this._exists(jdbcProperties, log, connection, sqlQueryObject, Long.valueOf(tableId));
  519.     }
  520.     
  521.     private boolean _exists(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, Long tableId) throws MultipleResultException, NotImplementedException, ServiceException, Exception {
  522.     
  523.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  524.                     new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  525.                 
  526.         boolean existsConfigurazioneServizio = false;

  528.         sqlQueryObject = sqlQueryObject.newSQLQueryObject();
  529.         sqlQueryObject.setANDLogicOperator(true);

  531.         sqlQueryObject.addFromTable(this.getConfigurazioneServizioFieldConverter().toTable(ConfigurazioneServizio.model()));
  532.         sqlQueryObject.addSelectField(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().ACCORDO,true));
  533.         sqlQueryObject.addWhereCondition("id=?");


  536.         // Exists configurazioneServizio
  537.         existsConfigurazioneServizio = jdbcUtilities.exists(sqlQueryObject.createSQLQuery(), jdbcProperties.isShowSql(),
  538.             new JDBCObject(tableId,Long.class));

  540.         
  541.         return existsConfigurazioneServizio;
  542.     
  543.     }
  544.     
  545.     private void joinEngine(IExpression expression, ISQLQueryObject sqlQueryObject) throws NotImplementedException, ServiceException, Exception{
  546.     
  547.         if(expression.inUseModel(ConfigurazioneServizio.model().CONFIGURAZIONE_SERVIZIO_AZIONE,false)){
  548.             String tableName1 = this.getConfigurazioneServizioFieldConverter().toTable(ConfigurazioneServizio.model().CONFIGURAZIONE_SERVIZIO_AZIONE);
  549.             String tableName2 = this.getConfigurazioneServizioFieldConverter().toTable(ConfigurazioneServizio.model());
  550.             sqlQueryObject.addWhereCondition(tableName1+".id_config_servizio="+tableName2+".id");
  551.         }
  552.         
  553.     }
  554.     
  555.     protected java.util.List<Object> getRootTablePrimaryKeyValuesEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdConfigurazioneServizio id) throws NotFoundException, ServiceException, NotImplementedException, Exception{
  556.         // Identificativi
  557.         java.util.List<Object> rootTableIdValues = new java.util.ArrayList<>();
  558.         Long longId = this.findIdConfigurazioneServizio(jdbcProperties, log, connection, sqlQueryObject.newSQLQueryObject(), id, true);
  559.         rootTableIdValues.add(longId);
  560.         return rootTableIdValues;
  561.     }
  562.     
  563.     protected Map<String, List<IField>> getMapTableToPKColumnEngine() throws NotImplementedException, Exception{
  564.     
  565.         ConfigurazioneServizioFieldConverter converter = this.getConfigurazioneServizioFieldConverter();
  566.         Map<String, List<IField>> mapTableToPKColumn = new java.util.HashMap<>();
  567.         UtilsTemplate<IField> utilities = new UtilsTemplate<>();

  569.         // ConfigurazioneServizio.model()
  570.         mapTableToPKColumn.put(converter.toTable(ConfigurazioneServizio.model()),
  571.             utilities.newList(
  572.                 new CustomField("id", Long.class, "id", converter.toTable(ConfigurazioneServizio.model()))
  573.             ));

  575.         // ConfigurazioneServizio.model().CONFIGURAZIONE_SERVIZIO_AZIONE
  576.         mapTableToPKColumn.put(converter.toTable(ConfigurazioneServizio.model().CONFIGURAZIONE_SERVIZIO_AZIONE),
  577.             utilities.newList(
  578.                 new CustomField("id", Long.class, "id", converter.toTable(ConfigurazioneServizio.model().CONFIGURAZIONE_SERVIZIO_AZIONE))
  579.             ));

  581.         // ConfigurazioneServizio.model().CONFIGURAZIONE_SERVIZIO_AZIONE.ID_CONFIGURAZIONE_SERVIZIO
  582.         mapTableToPKColumn.put(converter.toTable(ConfigurazioneServizio.model().CONFIGURAZIONE_SERVIZIO_AZIONE.ID_CONFIGURAZIONE_SERVIZIO),
  583.             utilities.newList(
  584.                 new CustomField("id", Long.class, "id", converter.toTable(ConfigurazioneServizio.model().CONFIGURAZIONE_SERVIZIO_AZIONE.ID_CONFIGURAZIONE_SERVIZIO))
  585.             ));
  586.         
  587.         return mapTableToPKColumn;      
  588.     }
  589.     
  590.     @Override
  591.     public List<Long> findAllTableIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCPaginatedExpression paginatedExpression) throws ServiceException, NotImplementedException, Exception {
  592.         
  593.         List<Long> list = new ArrayList<Long>();

  595.         sqlQueryObject.setSelectDistinct(true);
  596.         sqlQueryObject.setANDLogicOperator(true);
  597.         sqlQueryObject.addSelectField(this.getConfigurazioneServizioFieldConverter().toTable(ConfigurazioneServizio.model())+".id");
  598.         Class<?> objectIdClass = Long.class;
  599.         
  600.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareFindAll(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression,
  601.                                                 this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model());
  602.         
  603.         joinEngine(paginatedExpression,sqlQueryObject);
  604.         
  605.         List<Object> listObjects = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.findAll(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression,
  606.                                                                             this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model(), objectIdClass, listaQuery);
  607.         for(Object object: listObjects) {
  608.             list.add((Long)object);
  609.         }

  611.         return list;
  612.         
  613.     }
  614.     
  615.     @Override
  616.     public long findTableId(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression) throws ServiceException, NotFoundException, MultipleResultException, NotImplementedException, Exception {
  617.     
  618.         sqlQueryObject.setSelectDistinct(true);
  619.         sqlQueryObject.setANDLogicOperator(true);
  620.         sqlQueryObject.addSelectField(this.getConfigurazioneServizioFieldConverter().toTable(ConfigurazioneServizio.model())+".id");
  621.         Class<?> objectIdClass = Long.class;
  622.         
  623.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareFind(jdbcProperties, log, connection, sqlQueryObject, expression,
  624.                                                 this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model());
  625.         
  626.         joinEngine(expression,sqlQueryObject);

  628.         Object res = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.find(jdbcProperties, log, connection, sqlQueryObject, expression,
  629.                                                         this.getConfigurazioneServizioFieldConverter(), ConfigurazioneServizio.model(), objectIdClass, listaQuery);
  630.         if(res!=null && (((Long) res).longValue()>0) ){
  631.             return ((Long) res).longValue();
  632.         }
  633.         else{
  634.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  635.         }
  636.         
  637.     }

  639.     @Override
  640.     public InUse inUse(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId) throws ServiceException, NotFoundException, NotImplementedException, Exception {
  641.         return this.inUseEngine(jdbcProperties, log, connection, sqlQueryObject, Long.valueOf(tableId));
  642.     }

  644.     private InUse inUseEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, Long tableId) throws ServiceException, NotFoundException, NotImplementedException, Exception {

  646.         InUse inUse = new InUse();
  647.         inUse.setInUse(false);
  648.         
  649.         /* 
  650.          * TODO: implement code that checks whether the object identified by the id parameter is used by other objects
  651.         */
  652.         
  653.         // Delete this line when you have implemented the method
  654.         int throwNotImplemented = 1;
  655.         if(throwNotImplemented==1){
  656.                 throw new NotImplementedException("NotImplemented");
  657.         }
  658.         // Delete this line when you have implemented the method

  660.         return inUse;

  662.     }
  663.     
  664.     @Override
  665.     public IdConfigurazioneServizio findId(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId, boolean throwNotFound)
  666.             throws NotFoundException, ServiceException, NotImplementedException, Exception {
  667.         
  668.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  669.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);

  671.         ISQLQueryObject sqlQueryObjectGet = sqlQueryObject.newSQLQueryObject();
  672.              

  674.         // Object _configurazioneServizio
  675.         sqlQueryObjectGet.addFromTable(this.getConfigurazioneServizioFieldConverter().toTable(ConfigurazioneServizio.model()));
  676.         sqlQueryObjectGet.addSelectField(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().TIPO_SOGGETTO_REFERENTE,true));
  677.         sqlQueryObjectGet.addSelectField(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().NOME_SOGGETTO_REFERENTE,true));
  678.         sqlQueryObjectGet.addSelectField(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().ACCORDO,true));
  679.         sqlQueryObjectGet.addSelectField(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().SERVIZIO,true));
  680.         sqlQueryObjectGet.addSelectField(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().VERSIONE,true));
  681.         sqlQueryObjectGet.setANDLogicOperator(true);
  682.         sqlQueryObjectGet.addWhereCondition("id=?");

  684.         // Recupero _configurazioneServizio
  685.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] searchParams_configurazioneServizio = new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] { 
  686.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject(tableId,Long.class)
  687.         };
  688.         List<Class<?>> listaFieldIdReturnType_configurazioneServizio = new ArrayList<Class<?>>();
  689.         listaFieldIdReturnType_configurazioneServizio.add(String.class);
  690.         listaFieldIdReturnType_configurazioneServizio.add(String.class);
  691.         listaFieldIdReturnType_configurazioneServizio.add(String.class);
  692.         listaFieldIdReturnType_configurazioneServizio.add(String.class);
  693.         listaFieldIdReturnType_configurazioneServizio.add(Integer.class);
  694.         org.openspcoop2.core.plugins.IdConfigurazioneServizio id_configurazioneServizio = null;
  695.         List<Object> listaFieldId_configurazioneServizio = jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet.createSQLQuery(), jdbcProperties.isShowSql(),
  696.                 listaFieldIdReturnType_configurazioneServizio, searchParams_configurazioneServizio);
  697.         if(listaFieldId_configurazioneServizio==null || listaFieldId_configurazioneServizio.size()<=0){
  698.             if(throwNotFound){
  699.                 throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  700.             }
  701.         }
  702.         else{
  703.             // set _configurazioneServizio
  704.             id_configurazioneServizio = new org.openspcoop2.core.plugins.IdConfigurazioneServizio();
  705.             id_configurazioneServizio.setTipoSoggettoReferente((String)listaFieldId_configurazioneServizio.get(0));
  706.             id_configurazioneServizio.setNomeSoggettoReferente((String)listaFieldId_configurazioneServizio.get(1));
  707.             id_configurazioneServizio.setAccordo((String)listaFieldId_configurazioneServizio.get(2));
  708.             id_configurazioneServizio.setServizio((String)listaFieldId_configurazioneServizio.get(3));
  709.             id_configurazioneServizio.setVersione((Integer)listaFieldId_configurazioneServizio.get(4));
  710.         }
  711.         
  712.         return id_configurazioneServizio;
  713.         
  714.     }

  716.     @Override
  717.     public Long findTableId(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdConfigurazioneServizio id, boolean throwNotFound)
  718.             throws NotFoundException, ServiceException, NotImplementedException, Exception {
  719.     
  720.         return this.findIdConfigurazioneServizio(jdbcProperties,log,connection,sqlQueryObject,id,throwNotFound);
  721.             
  722.     }
  723.     
  724.     @Override
  725.     public List<List<Object>> nativeQuery(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  726.                                             String sql,List<Class<?>> returnClassTypes,Object ... param) throws ServiceException,NotFoundException,NotImplementedException,Exception{
  727.         
  728.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.nativeQuery(jdbcProperties, log, connection, sqlQueryObject,
  729.                                                                                             sql,returnClassTypes,param);
  730.                                                         
  731.     }
  732.     
  733.     protected Long findIdConfigurazioneServizio(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdConfigurazioneServizio id, boolean throwNotFound) throws NotFoundException, ServiceException, NotImplementedException, Exception {

  735.         if(jdbcProperties==null) {
  736.             throw new ServiceException("Param jdbcProperties is null");
  737.         }
  738.         if(sqlQueryObject==null) {
  739.             throw new ServiceException("Param sqlQueryObject is null");
  740.         }
  741.         if(id==null) {
  742.             throw new ServiceException("Param id is null");
  743.         }
  744.         
  745.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  746.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);

  748.         ISQLQueryObject sqlQueryObjectGet = sqlQueryObject.newSQLQueryObject();

  750.         // Object _configurazioneServizio
  751.         sqlQueryObjectGet.addFromTable(this.getConfigurazioneServizioFieldConverter().toTable(ConfigurazioneServizio.model()));
  752.         sqlQueryObjectGet.addSelectField("id");
  753.         sqlQueryObjectGet.setANDLogicOperator(true);
  754.         sqlQueryObjectGet.setSelectDistinct(true);
  755.         sqlQueryObjectGet.addWhereCondition(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().ACCORDO,true)+"=?");
  756.         sqlQueryObjectGet.addWhereCondition(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().TIPO_SOGGETTO_REFERENTE,true)+"=?");
  757.         sqlQueryObjectGet.addWhereCondition(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().NOME_SOGGETTO_REFERENTE,true)+"=?");
  758.         sqlQueryObjectGet.addWhereCondition(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().VERSIONE,true)+"=?");
  759.         sqlQueryObjectGet.addWhereCondition(this.getConfigurazioneServizioFieldConverter().toColumn(ConfigurazioneServizio.model().SERVIZIO,true)+"=?");

  761.         // Recupero _configurazioneServizio
  762.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] searchParams_configurazioneServizio = new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] { 
  763.                 new JDBCObject(id.getAccordo(), String.class),
  764.                 new JDBCObject(id.getTipoSoggettoReferente(), String.class),
  765.                 new JDBCObject(id.getNomeSoggettoReferente(), String.class),
  766.                 new JDBCObject(id.getVersione(), String.class),
  767.                 new JDBCObject(id.getServizio(), String.class)
  768.         };
  769.         Long id_configurazioneServizio = null;
  770.         try{
  771.             id_configurazioneServizio = (Long) jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet.createSQLQuery(), jdbcProperties.isShowSql(),
  772.                         Long.class, searchParams_configurazioneServizio);
  773.         }catch(NotFoundException notFound){
  774.             if(throwNotFound){
  775.                 throw new NotFoundException(notFound);
  776.             }
  777.         }
  778.         if(id_configurazioneServizio==null || id_configurazioneServizio<=0){
  779.             if(throwNotFound){
  780.                 throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  781.             }
  782.         }
  783.         
  784.         return id_configurazioneServizio;
  785.     }
  786. }
Created with JaCoCo 0.8.8.202204050719