JDBCAccordoServizioParteSpecificaServiceSearchImpl.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.commons.search.dao.jdbc;

  21. import java.util.List;
  22. import java.util.ArrayList;
  23. import java.util.Map;

  24. import java.sql.Connection;

  25. import org.slf4j.Logger;

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

  27. import org.openspcoop2.generic_project.expression.impl.sql.ISQLFieldConverter;
  28. import org.openspcoop2.generic_project.dao.jdbc.utils.IJDBCFetch;
  29. import org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject;
  30. import org.openspcoop2.generic_project.dao.jdbc.IJDBCServiceSearchWithId;
  31. import org.openspcoop2.core.commons.search.IdAccordoServizioParteSpecifica;
  32. import org.openspcoop2.core.commons.search.IdSoggetto;
  33. import org.openspcoop2.core.commons.search.Soggetto;
  34. import org.openspcoop2.generic_project.utils.UtilsTemplate;
  35. import org.openspcoop2.generic_project.beans.AliasField;
  36. import org.openspcoop2.generic_project.beans.CustomField;
  37. import org.openspcoop2.generic_project.beans.InUse;
  38. import org.openspcoop2.generic_project.beans.IField;
  39. import org.openspcoop2.generic_project.beans.NonNegativeNumber;
  40. import org.openspcoop2.generic_project.beans.UnionExpression;
  41. import org.openspcoop2.generic_project.beans.Union;
  42. import org.openspcoop2.generic_project.beans.FunctionField;
  43. import org.openspcoop2.generic_project.exception.MultipleResultException;
  44. import org.openspcoop2.generic_project.exception.NotFoundException;
  45. import org.openspcoop2.generic_project.exception.NotImplementedException;
  46. import org.openspcoop2.generic_project.exception.ServiceException;
  47. import org.openspcoop2.generic_project.expression.IExpression;
  48. import org.openspcoop2.generic_project.dao.jdbc.JDBCExpression;
  49. import org.openspcoop2.generic_project.dao.jdbc.JDBCPaginatedExpression;

  50. import org.openspcoop2.generic_project.dao.jdbc.JDBCServiceManagerProperties;
  51. import org.openspcoop2.core.commons.search.dao.jdbc.converter.AccordoServizioParteSpecificaFieldConverter;
  52. import org.openspcoop2.core.commons.search.dao.jdbc.fetch.AccordoServizioParteSpecificaFetch;
  53. import org.openspcoop2.core.commons.search.dao.IDBSoggettoServiceSearch;
  54. import org.openspcoop2.core.commons.search.dao.ISoggettoServiceSearch;
  55. import org.openspcoop2.core.commons.search.AccordoServizioParteSpecifica;
  56. import org.openspcoop2.core.commons.search.IdAccordoServizioParteComune;

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

  65.     private AccordoServizioParteSpecificaFieldConverter _accordoServizioParteSpecificaFieldConverter = null;
  66.     public AccordoServizioParteSpecificaFieldConverter getAccordoServizioParteSpecificaFieldConverter() {
  67.         if(this._accordoServizioParteSpecificaFieldConverter==null){
  68.             this._accordoServizioParteSpecificaFieldConverter = new AccordoServizioParteSpecificaFieldConverter(this.jdbcServiceManager.getJdbcProperties().getDatabaseType());
  69.         }      
  70.         return this._accordoServizioParteSpecificaFieldConverter;
  71.     }
  72.     @Override
  73.     public ISQLFieldConverter getFieldConverter() {
  74.         return this.getAccordoServizioParteSpecificaFieldConverter();
  75.     }
  76.    
  77.     private AccordoServizioParteSpecificaFetch accordoServizioParteSpecificaFetch = new AccordoServizioParteSpecificaFetch();
  78.     public AccordoServizioParteSpecificaFetch getAccordoServizioParteSpecificaFetch() {
  79.         return this.accordoServizioParteSpecificaFetch;
  80.     }
  81.     @Override
  82.     public IJDBCFetch getFetch() {
  83.         return getAccordoServizioParteSpecificaFetch();
  84.     }
  85.    
  86.    
  87.     private JDBCServiceManager jdbcServiceManager = null;

  88.     @Override
  89.     public void setServiceManager(JDBCServiceManager serviceManager) throws ServiceException{
  90.         this.jdbcServiceManager = serviceManager;
  91.     }
  92.    
  93.     @Override
  94.     public JDBCServiceManager getServiceManager() throws ServiceException{
  95.         return this.jdbcServiceManager;
  96.     }
  97.     public JDBCServiceManager getServiceManager(Connection connection, JDBCServiceManagerProperties jdbcProperties, Logger log) throws ServiceException{
  98.         return new JDBCServiceManager(connection, jdbcProperties, log);
  99.     }
  100.    

  101.     @Override
  102.     public IdAccordoServizioParteSpecifica convertToId(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, AccordoServizioParteSpecifica accordoServizioParteSpecifica) throws NotImplementedException, ServiceException, Exception{
  103.    
  104.         IdAccordoServizioParteSpecifica idAccordoServizioParteSpecifica = new IdAccordoServizioParteSpecifica();
  105.         idAccordoServizioParteSpecifica.setTipo(accordoServizioParteSpecifica.getTipo());
  106.         idAccordoServizioParteSpecifica.setNome(accordoServizioParteSpecifica.getNome());
  107.         idAccordoServizioParteSpecifica.setVersione(accordoServizioParteSpecifica.getVersione());
  108.         idAccordoServizioParteSpecifica.setIdErogatore(accordoServizioParteSpecifica.getIdErogatore());
  109.         return idAccordoServizioParteSpecifica;

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

  122.         Long id_accordoServizioParteSpecifica = this.findIdAccordoServizioParteSpecifica(jdbcProperties, log, connection, sqlQueryObject, id, false);
  123.         return id_accordoServizioParteSpecifica != null && id_accordoServizioParteSpecifica > 0;
  124.        
  125.     }
  126.    
  127.     @Override
  128.     public List<IdAccordoServizioParteSpecifica> findAllIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCPaginatedExpression expression, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotImplementedException, ServiceException,Exception {

  129.         List<IdAccordoServizioParteSpecifica> list = new ArrayList<IdAccordoServizioParteSpecifica>();

  130.         // TODO: implementazione non efficiente.
  131.         // Per ottenere una implementazione efficiente:
  132.         // 1. Usare metodo select di questa classe indirizzando esattamente i field necessari a create l'ID logico
  133.         // 2. Usare metodo getAccordoServizioParteSpecificaFetch() sul risultato della select per ottenere un oggetto AccordoServizioParteSpecifica
  134.         //    La fetch con la map inserirĂ  nell'oggetto solo i valori estratti
  135.         // 3. Usare metodo convertToId per ottenere l'id

  136.         List<Long> ids = this.findAllTableIds(jdbcProperties, log, connection, sqlQueryObject, expression);
  137.        
  138.         for(Long id: ids) {
  139.             AccordoServizioParteSpecifica accordoServizioParteSpecifica = this.get(jdbcProperties, log, connection, sqlQueryObject, id, idMappingResolutionBehaviour);
  140.             IdAccordoServizioParteSpecifica idAccordoServizioParteSpecifica = this.convertToId(jdbcProperties,log,connection,sqlQueryObject,accordoServizioParteSpecifica);
  141.             list.add(idAccordoServizioParteSpecifica);
  142.         }

  143.         return list;
  144.        
  145.     }
  146.    
  147.     private static boolean efficiente = true;
  148.    
  149.     @Override
  150.     public List<AccordoServizioParteSpecifica> findAll(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCPaginatedExpression expression, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotImplementedException, ServiceException,Exception {

  151.         List<AccordoServizioParteSpecifica> list = new ArrayList<AccordoServizioParteSpecifica>();
  152.        
  153.         if(efficiente){
  154.            
  155.             List<IField> fields = new ArrayList<IField>();
  156.             fields.add(AccordoServizioParteSpecifica.model().TIPO);
  157.             fields.add(AccordoServizioParteSpecifica.model().NOME);
  158.             fields.add(AccordoServizioParteSpecifica.model().VERSIONE);
  159.             fields.add(AccordoServizioParteSpecifica.model().PORT_TYPE);
  160.             String aliasAccordoNome = "accordoNome";
  161.             fields.add(new AliasField(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.NOME, aliasAccordoNome));
  162.             String aliasAccordoVersione = "accordoVersione";
  163.             fields.add(new AliasField(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.VERSIONE, aliasAccordoVersione));
  164.             String aliasAccordoSoggettoReferenteTipo = "accordoSoggettoReferenteTipo";
  165.             fields.add(new AliasField(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.TIPO, aliasAccordoSoggettoReferenteTipo));
  166.             String aliasAccordoSoggettoReferenteNome = "accordoSoggettoReferenteNome";
  167.             fields.add(new AliasField(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO.NOME, aliasAccordoSoggettoReferenteNome));
  168.             String aliasSoggettoErogatoreTipo = "accordoSoggettoErogatoreTipo";
  169.             fields.add(new AliasField(AccordoServizioParteSpecifica.model().ID_EROGATORE.TIPO, aliasSoggettoErogatoreTipo));
  170.             String aliasSoggettoErogatoreNome = "accordoSoggettoErogatoreNome";
  171.             fields.add(new AliasField(AccordoServizioParteSpecifica.model().ID_EROGATORE.NOME, aliasSoggettoErogatoreNome));
  172.            
  173.             List<Map<String, Object>> returnMap = null;
  174.             try{
  175.                 // non usare true altrimenti non funzionano alcuni meccanismi di ricerca, ad es. la valorizzazione dei select field nel servizio della govwayMonitor.
  176.                 // Tanto le join non comportano righe multiple uguali
  177.                 boolean distinct = false;
  178.                 returnMap = this.select(jdbcProperties, log, connection, sqlQueryObject, expression, distinct, fields.toArray(new IField[1]));
  179.                
  180.                 for(Map<String, Object> map: returnMap) {
  181.                    
  182.                     AccordoServizioParteSpecifica asps = (AccordoServizioParteSpecifica) this.getAccordoServizioParteSpecificaFetch().fetch(jdbcProperties.getDatabase(), AccordoServizioParteSpecifica.model(), map);
  183.                    
  184.                     Object apcNome = this.getObjectFromMap(map, aliasAccordoNome);
  185.                     Object apcVersione = this.getObjectFromMap(map, aliasAccordoVersione);
  186.                     Object apcSoggettoReferenteTipo = this.getObjectFromMap(map, aliasAccordoSoggettoReferenteTipo);
  187.                     Object apcSoggettoReferenteNome = this.getObjectFromMap(map, aliasAccordoSoggettoReferenteNome);
  188.                     Object soggettoErogatoreTipo = this.getObjectFromMap(map, aliasSoggettoErogatoreTipo);
  189.                     Object soggettoErogatoreNome = this.getObjectFromMap(map, aliasSoggettoErogatoreNome);
  190.                     if(apcNome!=null && apcVersione!=null) {
  191.                         IdAccordoServizioParteComune idAccordoServizioParteComune = new IdAccordoServizioParteComune();
  192.                         if(apcNome!=null && apcNome instanceof String) {
  193.                             idAccordoServizioParteComune.setNome((String) apcNome);
  194.                         }
  195.                         if(apcVersione!=null && apcVersione instanceof Integer) {
  196.                             idAccordoServizioParteComune.setVersione((Integer) apcVersione);
  197.                         }
  198.                         if(apcSoggettoReferenteTipo!=null && apcSoggettoReferenteNome!=null) {
  199.                             IdSoggetto idSoggetto = new IdSoggetto();
  200.                             if(apcSoggettoReferenteTipo!=null && apcSoggettoReferenteTipo instanceof String) {
  201.                                 idSoggetto.setTipo((String) apcSoggettoReferenteTipo);
  202.                             }
  203.                             if(apcSoggettoReferenteNome!=null && apcSoggettoReferenteNome instanceof String) {
  204.                                 idSoggetto.setNome((String) apcSoggettoReferenteNome);
  205.                             }
  206.                             idAccordoServizioParteComune.setIdSoggetto(idSoggetto);
  207.                         }
  208.                         asps.setIdAccordoServizioParteComune(idAccordoServizioParteComune);
  209.                     }
  210.                     if(soggettoErogatoreTipo!=null && soggettoErogatoreNome!=null) {
  211.                         IdSoggetto idSoggetto = new IdSoggetto();
  212.                         if(soggettoErogatoreTipo!=null && soggettoErogatoreTipo instanceof String) {
  213.                             idSoggetto.setTipo((String) soggettoErogatoreTipo);
  214.                         }
  215.                         if(soggettoErogatoreNome!=null && soggettoErogatoreNome instanceof String) {
  216.                             idSoggetto.setNome((String) soggettoErogatoreNome);
  217.                         }
  218.                         asps.setIdErogatore(idSoggetto);
  219.                     }          
  220.                    
  221.                     list.add(asps);
  222.                 }
  223.             }catch(NotFoundException notFound){}
  224.         }

  225.         else{

  226.             List<Long> ids = this.findAllTableIds(jdbcProperties, log, connection, sqlQueryObject, expression);
  227.            
  228.             for(Long id: ids) {
  229.                 list.add(this.get(jdbcProperties, log, connection, sqlQueryObject, id, idMappingResolutionBehaviour));
  230.             }
  231.            
  232.         }

  233.         return list;      
  234.        
  235.     }
  236.    
  237.     private Object getObjectFromMap(Map<String,Object> map,String name){
  238.         if(map==null){
  239.             return null;
  240.         }
  241.         else if(map.containsKey(name)){
  242.             Object o = map.get(name);
  243.             if(o instanceof org.apache.commons.lang.ObjectUtils.Null){
  244.                 return null;
  245.             }
  246.             else{
  247.                 return o;
  248.             }
  249.         }
  250.         else{
  251.             return null;
  252.         }
  253.     }
  254.    
  255.     @Override
  256.     public AccordoServizioParteSpecifica find(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour)
  257.         throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException,Exception {

  258.         long id = this.findTableId(jdbcProperties, log, connection, sqlQueryObject, expression);
  259.         if(id>0){
  260.             return this.get(jdbcProperties, log, connection, sqlQueryObject, id, idMappingResolutionBehaviour);
  261.         }else{
  262.             throw new NotFoundException("Entry with id["+id+"] not found");
  263.         }
  264.        
  265.     }
  266.    
  267.     @Override
  268.     public NonNegativeNumber count(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression) throws NotImplementedException, ServiceException,Exception {
  269.        
  270.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareCount(jdbcProperties, log, connection, sqlQueryObject, expression,
  271.                                                 this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model());
  272.        
  273.         sqlQueryObject.addSelectCountField(this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model())+".id","tot",true);
  274.        
  275.         joinEngine(expression,sqlQueryObject);
  276.        
  277.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.count(jdbcProperties, log, connection, sqlQueryObject, expression,
  278.                                                                             this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model(),listaQuery);
  279.     }

  280.     @Override
  281.     public InUse inUse(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdAccordoServizioParteSpecifica id) throws NotFoundException, NotImplementedException, ServiceException,Exception {
  282.        
  283.         Long id_accordoServizioParteSpecifica = this.findIdAccordoServizioParteSpecifica(jdbcProperties, log, connection, sqlQueryObject, id, true);
  284.         return this.inUseEngine(jdbcProperties, log, connection, sqlQueryObject, id_accordoServizioParteSpecifica);
  285.        
  286.     }

  287.     @Override
  288.     public List<Object> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  289.                                                     JDBCPaginatedExpression paginatedExpression, IField field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  290.         return this.select(jdbcProperties, log, connection, sqlQueryObject,
  291.                                 paginatedExpression, false, field);
  292.     }
  293.    
  294.     @Override
  295.     public List<Object> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  296.                                                     JDBCPaginatedExpression paginatedExpression, boolean distinct, IField field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  297.         List<Map<String,Object>> map =
  298.             this.select(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression, distinct, new IField[]{field});
  299.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.selectSingleObject(map);
  300.     }
  301.    
  302.     @Override
  303.     public List<Map<String,Object>> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  304.                                                     JDBCPaginatedExpression paginatedExpression, IField ... field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  305.         return this.select(jdbcProperties, log, connection, sqlQueryObject,
  306.                                 paginatedExpression, false, field);
  307.     }
  308.    
  309.     @Override
  310.     public List<Map<String,Object>> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  311.                                                     JDBCPaginatedExpression paginatedExpression, boolean distinct, IField ... field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  312.        
  313.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,paginatedExpression,field);
  314.         try{
  315.        
  316.             ISQLQueryObject sqlQueryObjectDistinct =
  317.                         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSqlQueryObjectForSelectDistinct(distinct,sqlQueryObject, paginatedExpression, log,
  318.                                                 this.getAccordoServizioParteSpecificaFieldConverter(), field);

  319.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression, sqlQueryObjectDistinct);
  320.            
  321.         }finally{
  322.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,paginatedExpression,field);
  323.         }
  324.     }

  325.     @Override
  326.     public Object aggregate(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  327.                                                     JDBCExpression expression, FunctionField functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  328.         Map<String,Object> map =
  329.             this.aggregate(jdbcProperties, log, connection, sqlQueryObject, expression, new FunctionField[]{functionField});
  330.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.selectAggregateObject(map,functionField);
  331.     }
  332.    
  333.     @Override
  334.     public Map<String,Object> aggregate(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  335.                                                     JDBCExpression expression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {                                                  
  336.        
  337.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,expression,functionField);
  338.         try{
  339.             List<Map<String,Object>> list = selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression);
  340.             return list.get(0);
  341.         }finally{
  342.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,expression,functionField);
  343.         }
  344.     }

  345.     @Override
  346.     public List<Map<String,Object>> groupBy(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  347.                                                     JDBCExpression expression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  348.        
  349.         if(expression.getGroupByFields().isEmpty()){
  350.             throw new ServiceException("GroupBy conditions not found in expression");
  351.         }
  352.        
  353.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,expression,functionField);
  354.         try{
  355.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression);
  356.         }finally{
  357.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,expression,functionField);
  358.         }
  359.     }
  360.    

  361.     @Override
  362.     public List<Map<String,Object>> groupBy(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  363.                                                     JDBCPaginatedExpression paginatedExpression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  364.        
  365.         if(paginatedExpression.getGroupByFields().isEmpty()){
  366.             throw new ServiceException("GroupBy conditions not found in expression");
  367.         }
  368.        
  369.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,paginatedExpression,functionField);
  370.         try{
  371.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression);
  372.         }finally{
  373.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,paginatedExpression,functionField);
  374.         }
  375.     }
  376.    
  377.     protected List<Map<String,Object>> selectEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  378.                                                 IExpression expression) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  379.         return selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression, null);
  380.     }
  381.     protected List<Map<String,Object>> selectEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  382.                                                 IExpression expression, ISQLQueryObject sqlQueryObjectDistinct) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  383.        
  384.         List<Object> listaQuery = new ArrayList<>();
  385.         List<JDBCObject> listaParams = new ArrayList<>();
  386.         List<Object> returnField = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSelect(jdbcProperties, log, connection, sqlQueryObject,
  387.                                 expression, this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model(),
  388.                                 listaQuery,listaParams);
  389.        
  390.         joinEngine(expression,sqlQueryObject);
  391.        
  392.         List<Map<String,Object>> list = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.select(jdbcProperties, log, connection,
  393.                                         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSqlQueryObjectForSelectDistinct(sqlQueryObject,sqlQueryObjectDistinct),
  394.                                         expression, this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model(),
  395.                                         listaQuery,listaParams,returnField);
  396.         if(list!=null && !list.isEmpty()){
  397.             return list;
  398.         }
  399.         else{
  400.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  401.         }
  402.     }
  403.    
  404.     @Override
  405.     public List<Map<String,Object>> union(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  406.                                                 Union union, UnionExpression ... unionExpression) throws ServiceException,NotFoundException,NotImplementedException,Exception {    
  407.        
  408.         List<ISQLQueryObject> sqlQueryObjectInnerList = new ArrayList<>();
  409.         List<JDBCObject> jdbcObjects = new ArrayList<>();
  410.         List<Class<?>> returnClassTypes = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareUnion(jdbcProperties, log, connection, sqlQueryObject,
  411.                                 this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model(),
  412.                                 sqlQueryObjectInnerList, jdbcObjects, union, unionExpression);
  413.        
  414.         if(unionExpression!=null){
  415.             for (int i = 0; i < unionExpression.length; i++) {
  416.                 UnionExpression ue = unionExpression[i];
  417.                 IExpression expression = ue.getExpression();
  418.                 joinEngine(expression,sqlQueryObjectInnerList.get(i));
  419.             }
  420.         }
  421.        
  422.         List<Map<String,Object>> list = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.union(jdbcProperties, log, connection, sqlQueryObject,
  423.                                         this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model(),
  424.                                         sqlQueryObjectInnerList, jdbcObjects, returnClassTypes, union, unionExpression);
  425.         if(list!=null && !list.isEmpty()){
  426.             return list;
  427.         }
  428.         else{
  429.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  430.         }                              
  431.     }
  432.    
  433.     @Override
  434.     public NonNegativeNumber unionCount(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  435.                                                 Union union, UnionExpression ... unionExpression) throws ServiceException,NotFoundException,NotImplementedException,Exception {    
  436.        
  437.         List<ISQLQueryObject> sqlQueryObjectInnerList = new ArrayList<>();
  438.         List<JDBCObject> jdbcObjects = new ArrayList<>();
  439.         List<Class<?>> returnClassTypes = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareUnionCount(jdbcProperties, log, connection, sqlQueryObject,
  440.                                 this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model(),
  441.                                 sqlQueryObjectInnerList, jdbcObjects, union, unionExpression);
  442.        
  443.         if(unionExpression!=null){
  444.             for (int i = 0; i < unionExpression.length; i++) {
  445.                 UnionExpression ue = unionExpression[i];
  446.                 IExpression expression = ue.getExpression();
  447.                 joinEngine(expression,sqlQueryObjectInnerList.get(i));
  448.             }
  449.         }
  450.        
  451.         NonNegativeNumber number = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.unionCount(jdbcProperties, log, connection, sqlQueryObject,
  452.                                         this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model(),
  453.                                         sqlQueryObjectInnerList, jdbcObjects, returnClassTypes, union, unionExpression);
  454.         if(number!=null && number.longValue()>=0){
  455.             return number;
  456.         }
  457.         else{
  458.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  459.         }
  460.     }



  461.     // -- ConstructorExpression

  462.     @Override
  463.     public JDBCExpression newExpression(Logger log) throws NotImplementedException, ServiceException {
  464.         try{
  465.             return new JDBCExpression(this.getAccordoServizioParteSpecificaFieldConverter());
  466.         }catch(Exception e){
  467.             throw new ServiceException(e);
  468.         }
  469.     }


  470.     @Override
  471.     public JDBCPaginatedExpression newPaginatedExpression(Logger log) throws NotImplementedException, ServiceException {
  472.         try{
  473.             return new JDBCPaginatedExpression(this.getAccordoServizioParteSpecificaFieldConverter());
  474.         }catch(Exception e){
  475.             throw new ServiceException(e);
  476.         }
  477.     }
  478.    
  479.     @Override
  480.     public JDBCExpression toExpression(JDBCPaginatedExpression paginatedExpression, Logger log) throws NotImplementedException, ServiceException {
  481.         try{
  482.             return new JDBCExpression(paginatedExpression);
  483.         }catch(Exception e){
  484.             throw new ServiceException(e);
  485.         }
  486.     }

  487.     @Override
  488.     public JDBCPaginatedExpression toPaginatedExpression(JDBCExpression expression, Logger log) throws NotImplementedException, ServiceException {
  489.         try{
  490.             return new JDBCPaginatedExpression(expression);
  491.         }catch(Exception e){
  492.             throw new ServiceException(e);
  493.         }
  494.     }
  495.    
  496.    
  497.    
  498.     // -- DB

  499.     @Override
  500.     public void mappingTableIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdAccordoServizioParteSpecifica id, AccordoServizioParteSpecifica obj) throws NotFoundException,NotImplementedException,ServiceException,Exception{
  501.         _mappingTableIds(jdbcProperties,log,connection,sqlQueryObject,obj,
  502.                 this.get(jdbcProperties,log,connection,sqlQueryObject,id,null));
  503.     }
  504.    
  505.     @Override
  506.     public void mappingTableIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId, AccordoServizioParteSpecifica obj) throws NotFoundException,NotImplementedException,ServiceException,Exception{
  507.         _mappingTableIds(jdbcProperties,log,connection,sqlQueryObject,obj,
  508.                 this.get(jdbcProperties,log,connection,sqlQueryObject,tableId,null));
  509.     }
  510.     private void _mappingTableIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, AccordoServizioParteSpecifica obj, AccordoServizioParteSpecifica imgSaved) throws NotFoundException,NotImplementedException,ServiceException,Exception{
  511.         if(imgSaved==null){
  512.             return;
  513.         }
  514.         obj.setId(imgSaved.getId());
  515.         if(obj.getIdErogatore()!=null &&
  516.                 imgSaved.getIdErogatore()!=null){
  517.             obj.getIdErogatore().setId(imgSaved.getIdErogatore().getId());
  518.         }
  519.         if(obj.getIdAccordoServizioParteComune()!=null &&
  520.                 imgSaved.getIdAccordoServizioParteComune()!=null){
  521.             obj.getIdAccordoServizioParteComune().setId(imgSaved.getIdAccordoServizioParteComune().getId());
  522.             if(obj.getIdAccordoServizioParteComune().getIdSoggetto()!=null &&
  523.                     imgSaved.getIdAccordoServizioParteComune().getIdSoggetto()!=null){
  524.                 obj.getIdAccordoServizioParteComune().getIdSoggetto().setId(imgSaved.getIdAccordoServizioParteComune().getIdSoggetto().getId());
  525.             }
  526.         }

  527.     }
  528.    
  529.     @Override
  530.     public AccordoServizioParteSpecifica get(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException, Exception {
  531.         return this.getEngine(jdbcProperties, log, connection, sqlQueryObject, Long.valueOf(tableId), idMappingResolutionBehaviour);
  532.     }
  533.    
  534.     private AccordoServizioParteSpecifica getEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, Long tableId, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException, Exception {
  535.    
  536.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities =
  537.                     new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  538.        
  539.         ISQLQueryObject sqlQueryObjectGet = sqlQueryObject.newSQLQueryObject();
  540.                
  541.         AccordoServizioParteSpecifica accordoServizioParteSpecifica = new AccordoServizioParteSpecifica();
  542.        

  543.         // Object accordoServizioParteSpecifica
  544.         ISQLQueryObject sqlQueryObjectGet_accordoServizioParteSpecifica = sqlQueryObjectGet.newSQLQueryObject();
  545.         sqlQueryObjectGet_accordoServizioParteSpecifica.setANDLogicOperator(true);
  546.         sqlQueryObjectGet_accordoServizioParteSpecifica.addFromTable(this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model()));
  547.         sqlQueryObjectGet_accordoServizioParteSpecifica.addSelectField("id");
  548.         sqlQueryObjectGet_accordoServizioParteSpecifica.addSelectField(this.getAccordoServizioParteSpecificaFieldConverter().toColumn(AccordoServizioParteSpecifica.model().TIPO,true));
  549.         sqlQueryObjectGet_accordoServizioParteSpecifica.addSelectField(this.getAccordoServizioParteSpecificaFieldConverter().toColumn(AccordoServizioParteSpecifica.model().NOME,true));
  550.         sqlQueryObjectGet_accordoServizioParteSpecifica.addSelectField(this.getAccordoServizioParteSpecificaFieldConverter().toColumn(AccordoServizioParteSpecifica.model().VERSIONE,true));
  551.         sqlQueryObjectGet_accordoServizioParteSpecifica.addSelectField(this.getAccordoServizioParteSpecificaFieldConverter().toColumn(AccordoServizioParteSpecifica.model().PORT_TYPE,true));
  552.         sqlQueryObjectGet_accordoServizioParteSpecifica.addWhereCondition("id=?");

  553.         // Get accordoServizioParteSpecifica
  554.         accordoServizioParteSpecifica = (AccordoServizioParteSpecifica) jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet_accordoServizioParteSpecifica.createSQLQuery(), jdbcProperties.isShowSql(), AccordoServizioParteSpecifica.model(), this.getAccordoServizioParteSpecificaFetch(),
  555.             new JDBCObject(tableId,Long.class));


  556.         // Object _accordoServizioParteSpecifica_soggetto (recupero id)
  557.         ISQLQueryObject sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto_readFkId = sqlQueryObjectGet.newSQLQueryObject();
  558.         sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto_readFkId.addFromTable("servizi");
  559.         sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto_readFkId.addSelectField("id_soggetto");
  560.         sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto_readFkId.addWhereCondition("id=?");
  561.         sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto_readFkId.setANDLogicOperator(true);
  562.         Long idFK_accordoServizioParteSpecifica_soggetto = (Long) jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto_readFkId.createSQLQuery(), jdbcProperties.isShowSql(),Long.class,
  563.                 new JDBCObject(accordoServizioParteSpecifica.getId(),Long.class));
  564.        
  565.         // Object _accordoServizioParteSpecifica_soggetto
  566.         ISQLQueryObject sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto = sqlQueryObjectGet.newSQLQueryObject();
  567.         sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto.addFromTable("soggetti");
  568.         sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto.addSelectField("tipo_soggetto");
  569.         sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto.addSelectField("nome_soggetto");
  570.         sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto.setANDLogicOperator(true);
  571.         sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto.addWhereCondition("id=?");

  572.         // Recupero _accordoServizioParteSpecifica_soggetto
  573.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] searchParams_accordoServizioParteSpecifica_soggetto = new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] {
  574.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject(idFK_accordoServizioParteSpecifica_soggetto,Long.class)
  575.         };
  576.         List<Class<?>> listaFieldIdReturnType_accordoServizioParteSpecifica_soggetto = new ArrayList<Class<?>>();
  577.         listaFieldIdReturnType_accordoServizioParteSpecifica_soggetto.add(String.class);
  578.         listaFieldIdReturnType_accordoServizioParteSpecifica_soggetto.add(String.class);
  579.         List<Object> listaFieldId_accordoServizioParteSpecifica_soggetto = jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet_accordoServizioParteSpecifica_soggetto.createSQLQuery(), jdbcProperties.isShowSql(),
  580.                 listaFieldIdReturnType_accordoServizioParteSpecifica_soggetto, searchParams_accordoServizioParteSpecifica_soggetto);
  581.         // set _accordoServizioParteSpecifica_soggetto
  582.         IdSoggetto id_accordoServizioParteSpecifica_soggetto = new IdSoggetto();
  583.         id_accordoServizioParteSpecifica_soggetto.setTipo((String)listaFieldId_accordoServizioParteSpecifica_soggetto.get(0));
  584.         id_accordoServizioParteSpecifica_soggetto.setNome((String)listaFieldId_accordoServizioParteSpecifica_soggetto.get(1));
  585.         accordoServizioParteSpecifica.setIdErogatore(id_accordoServizioParteSpecifica_soggetto);

  586.        
  587.        
  588.         // Object _accordoServizioParteSpecifica_accordoServizioParteComune (recupero id)
  589.         ISQLQueryObject sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune_readFkId = sqlQueryObjectGet.newSQLQueryObject();
  590.         sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune_readFkId.addFromTable("servizi");
  591.         sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune_readFkId.addSelectField("id_accordo");
  592.         sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune_readFkId.addWhereCondition("id=?");
  593.         sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune_readFkId.setANDLogicOperator(true);
  594.         Long idFK_accordoServizioParteSpecifica_accordoServizioParteComune = (Long) jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune_readFkId.createSQLQuery(), jdbcProperties.isShowSql(),Long.class,
  595.                 new JDBCObject(accordoServizioParteSpecifica.getId(),Long.class));
  596.        
  597.         // Object _accordoServizioParteSpecifica_accordoServizioParteComune
  598.         ISQLQueryObject sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune = sqlQueryObjectGet.newSQLQueryObject();
  599.         sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune.addFromTable("accordi");
  600.         sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune.addSelectField("nome");
  601.         sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune.addSelectField("id_referente");
  602.         sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune.addSelectField("versione");
  603.         sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune.addSelectField("service_binding");
  604.         sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune.setANDLogicOperator(true);
  605.         sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune.addWhereCondition("id=?");

  606.         // Recupero _accordoServizioParteSpecifica_accordoServizioParteComune
  607.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] searchParams_accordoServizioParteSpecifica_accordoServizioParteComune = new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] {
  608.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject(idFK_accordoServizioParteSpecifica_accordoServizioParteComune,Long.class)
  609.         };
  610.         List<Class<?>> listaFieldIdReturnType_accordoServizioParteSpecifica_accordoServizioParteComune = new ArrayList<Class<?>>();
  611.         listaFieldIdReturnType_accordoServizioParteSpecifica_accordoServizioParteComune.add(String.class);
  612.         listaFieldIdReturnType_accordoServizioParteSpecifica_accordoServizioParteComune.add(Long.class);
  613.         listaFieldIdReturnType_accordoServizioParteSpecifica_accordoServizioParteComune.add(Integer.class);
  614.         listaFieldIdReturnType_accordoServizioParteSpecifica_accordoServizioParteComune.add(String.class);

  615.         List<Object> listaFieldId_accordoServizioParteSpecifica_accordoServizioParteComune = jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet_accordoServizioParteSpecifica_accordoServizioParteComune.createSQLQuery(), jdbcProperties.isShowSql(),
  616.                 listaFieldIdReturnType_accordoServizioParteSpecifica_accordoServizioParteComune, searchParams_accordoServizioParteSpecifica_accordoServizioParteComune);
  617.         String accordo_nome = (String) listaFieldId_accordoServizioParteSpecifica_accordoServizioParteComune.get(0);
  618.         Long accordo_id_referente = (Long) listaFieldId_accordoServizioParteSpecifica_accordoServizioParteComune.get(1);
  619.         Integer accordo_versione = (Integer) listaFieldId_accordoServizioParteSpecifica_accordoServizioParteComune.get(2);
  620.         String accordo_serviceBinding = (String) listaFieldId_accordoServizioParteSpecifica_accordoServizioParteComune.get(3);
  621.        
  622.         // Recupero SoggettoReferente accordo
  623.         Soggetto accordo_id_referente_soggetto = null;
  624.         if(accordo_id_referente!=null && accordo_id_referente>0){
  625.             ISoggettoServiceSearch soggettoServiceSearch = this.getServiceManager(connection, jdbcProperties, log).getSoggettoServiceSearch();
  626.             accordo_id_referente_soggetto = ((IDBSoggettoServiceSearch)soggettoServiceSearch).get(accordo_id_referente);
  627.         }
  628.        
  629.         // set _accordoServizioParteSpecifica_accordoServizioParteComune
  630.         IdAccordoServizioParteComune idAccordoServizioParteComune = new IdAccordoServizioParteComune();
  631.         idAccordoServizioParteComune.setNome(accordo_nome);
  632.         idAccordoServizioParteComune.setVersione(accordo_versione);
  633.         idAccordoServizioParteComune.setServiceBinding(accordo_serviceBinding);
  634.         IdSoggetto idAccordoServizioParteComune_referente = null;
  635.         if(accordo_id_referente_soggetto!=null){
  636.             idAccordoServizioParteComune_referente = new IdSoggetto();
  637.             idAccordoServizioParteComune_referente.setTipo(accordo_id_referente_soggetto.getTipoSoggetto());
  638.             idAccordoServizioParteComune_referente.setNome(accordo_id_referente_soggetto.getNomeSoggetto());
  639.         }
  640.         idAccordoServizioParteComune.setIdSoggetto(idAccordoServizioParteComune_referente);
  641.         accordoServizioParteSpecifica.setIdAccordoServizioParteComune(idAccordoServizioParteComune);
  642.                    
  643.         return accordoServizioParteSpecifica;  
  644.    
  645.     }
  646.    
  647.     @Override
  648.     public boolean exists(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId) throws MultipleResultException, NotImplementedException, ServiceException, Exception {
  649.         return this._exists(jdbcProperties, log, connection, sqlQueryObject, Long.valueOf(tableId));
  650.     }
  651.    
  652.     private boolean _exists(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, Long tableId) throws MultipleResultException, NotImplementedException, ServiceException, Exception {
  653.    
  654.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities =
  655.                     new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  656.                
  657.         boolean existsAccordoServizioParteSpecifica = false;

  658.         sqlQueryObject = sqlQueryObject.newSQLQueryObject();
  659.         sqlQueryObject.setANDLogicOperator(true);

  660.         sqlQueryObject.addFromTable(this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model()));
  661.         sqlQueryObject.addSelectField(this.getAccordoServizioParteSpecificaFieldConverter().toColumn(AccordoServizioParteSpecifica.model().TIPO,true));
  662.         sqlQueryObject.addWhereCondition("id=?");


  663.         // Exists accordoServizioParteSpecifica
  664.         existsAccordoServizioParteSpecifica = jdbcUtilities.exists(sqlQueryObject.createSQLQuery(), jdbcProperties.isShowSql(),
  665.             new JDBCObject(tableId,Long.class));

  666.        
  667.         return existsAccordoServizioParteSpecifica;
  668.    
  669.     }
  670.    
  671.     private void joinEngine(IExpression expression, ISQLQueryObject sqlQueryObject) throws NotImplementedException, ServiceException, Exception{
  672.    
  673.         if(expression.inUseModel(AccordoServizioParteSpecifica.model().ID_EROGATORE,false)){
  674.             String tableName1 = this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model());
  675.             //String tableName2 = "sogerog";
  676.             String tableName2 = this.getAccordoServizioParteSpecificaFieldConverter().toAliasTable(AccordoServizioParteSpecifica.model().ID_EROGATORE);
  677.             sqlQueryObject.addWhereCondition(tableName1+".id_soggetto="+tableName2+".id");
  678.         }
  679.         if(expression.inUseModel(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE,false)){
  680.             String tableName1 = this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model());
  681.             String tableName2 = this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE);
  682.             sqlQueryObject.addWhereCondition(tableName1+".id_accordo="+tableName2+".id");
  683.         }
  684.         if(expression.inUseModel(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO,false)){
  685.             String tableName1 = this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE);
  686.             //String tableName2 = "sogref";
  687.             String tableName2 = this.getAccordoServizioParteSpecificaFieldConverter().toAliasTable(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO);
  688.             sqlQueryObject.addWhereCondition(tableName1+".id_referente="+tableName2+".id");
  689.         }
  690.        
  691.         if(expression.inUseModel(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO,false)){
  692.             if(expression.inUseModel(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE,false)==false){
  693.                 sqlQueryObject.addFromTable(this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE));
  694.             }
  695.         }
  696.        
  697.     }
  698.    
  699.     protected java.util.List<Object> getRootTablePrimaryKeyValuesEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdAccordoServizioParteSpecifica id) throws NotFoundException, ServiceException, NotImplementedException, Exception{
  700.         // Identificativi
  701.         java.util.List<Object> rootTableIdValues = new java.util.ArrayList<>();
  702.         Long longId = this.findIdAccordoServizioParteSpecifica(jdbcProperties, log, connection, sqlQueryObject.newSQLQueryObject(), id, true);
  703.         rootTableIdValues.add(longId);
  704.         return rootTableIdValues;
  705.     }
  706.    
  707.     protected Map<String, List<IField>> getMapTableToPKColumnEngine() throws NotImplementedException, Exception{
  708.    
  709.         AccordoServizioParteSpecificaFieldConverter converter = this.getAccordoServizioParteSpecificaFieldConverter();
  710.         Map<String, List<IField>> mapTableToPKColumn = new java.util.HashMap<>();
  711.         UtilsTemplate<IField> utilities = new UtilsTemplate<>();

  712.         // AccordoServizioParteSpecifica.model()
  713.         mapTableToPKColumn.put(converter.toTable(AccordoServizioParteSpecifica.model()),
  714.             utilities.newList(
  715.                 new CustomField("id", Long.class, "id", converter.toTable(AccordoServizioParteSpecifica.model()))
  716.             ));

  717.         // AccordoServizioParteSpecifica.model().ID_EROGATORE
  718.         mapTableToPKColumn.put(converter.toTable(AccordoServizioParteSpecifica.model().ID_EROGATORE),
  719.             utilities.newList(
  720.                 new CustomField("id", Long.class, "id", converter.toTable(AccordoServizioParteSpecifica.model().ID_EROGATORE))
  721.             ));

  722.         // AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE
  723.         mapTableToPKColumn.put(converter.toTable(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE),
  724.             utilities.newList(
  725.                 new CustomField("id", Long.class, "id", converter.toTable(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE))
  726.             ));

  727.         // AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO
  728.         mapTableToPKColumn.put(converter.toTable(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO),
  729.             utilities.newList(
  730.                 new CustomField("id", Long.class, "id", converter.toTable(AccordoServizioParteSpecifica.model().ID_ACCORDO_SERVIZIO_PARTE_COMUNE.ID_SOGGETTO))
  731.             ));

  732.         return mapTableToPKColumn;      
  733.     }
  734.    
  735.     @Override
  736.     public List<Long> findAllTableIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCPaginatedExpression paginatedExpression) throws ServiceException, NotImplementedException, Exception {
  737.        
  738.         List<Long> list = new ArrayList<Long>();

  739.         sqlQueryObject.setSelectDistinct(true);
  740.         sqlQueryObject.setANDLogicOperator(true);
  741.         sqlQueryObject.addSelectField(this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model())+".id");
  742.         Class<?> objectIdClass = Long.class;
  743.        
  744.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareFindAll(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression,
  745.                                                 this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model());
  746.        
  747.         joinEngine(paginatedExpression,sqlQueryObject);
  748.        
  749.         List<Object> listObjects = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.findAll(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression,
  750.                                                                             this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model(), objectIdClass, listaQuery);
  751.         for(Object object: listObjects) {
  752.             list.add((Long)object);
  753.         }

  754.         return list;
  755.        
  756.     }
  757.    
  758.     @Override
  759.     public long findTableId(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression) throws ServiceException, NotFoundException, MultipleResultException, NotImplementedException, Exception {
  760.    
  761.         sqlQueryObject.setSelectDistinct(true);
  762.         sqlQueryObject.setANDLogicOperator(true);
  763.         sqlQueryObject.addSelectField(this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model())+".id");
  764.         Class<?> objectIdClass = Long.class;
  765.        
  766.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareFind(jdbcProperties, log, connection, sqlQueryObject, expression,
  767.                                                 this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model());
  768.        
  769.         joinEngine(expression,sqlQueryObject);

  770.         Object res = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.find(jdbcProperties, log, connection, sqlQueryObject, expression,
  771.                                                         this.getAccordoServizioParteSpecificaFieldConverter(), AccordoServizioParteSpecifica.model(), objectIdClass, listaQuery);
  772.         if(res!=null && (((Long) res).longValue()>0) ){
  773.             return ((Long) res).longValue();
  774.         }
  775.         else{
  776.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  777.         }
  778.        
  779.     }

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

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

  785.         InUse inUse = new InUse();
  786.         inUse.setInUse(false);
  787.        
  788.         /*
  789.          * TODO: implement code that checks whether the object identified by the id parameter is used by other objects
  790.         */
  791.        
  792.         // Delete this line when you have implemented the method
  793.         int throwNotImplemented = 1;
  794.         if(throwNotImplemented==1){
  795.                 throw new NotImplementedException("NotImplemented");
  796.         }
  797.         // Delete this line when you have implemented the method

  798.         return inUse;

  799.     }
  800.    
  801.     @Override
  802.     public IdAccordoServizioParteSpecifica findId(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId, boolean throwNotFound)
  803.             throws NotFoundException, ServiceException, NotImplementedException, Exception {
  804.        
  805.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities =
  806.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);

  807.         ISQLQueryObject sqlQueryObjectGet = sqlQueryObject.newSQLQueryObject();

  808.         // Object _accordoServizioParteSpecifica
  809.         sqlQueryObjectGet.addFromTable(this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model()));
  810.         sqlQueryObjectGet.addSelectField(this.getAccordoServizioParteSpecificaFieldConverter().toColumn(AccordoServizioParteSpecifica.model().TIPO,true));
  811.         sqlQueryObjectGet.addSelectField(this.getAccordoServizioParteSpecificaFieldConverter().toColumn(AccordoServizioParteSpecifica.model().NOME,true));
  812.         sqlQueryObjectGet.addSelectField(this.getAccordoServizioParteSpecificaFieldConverter().toColumn(AccordoServizioParteSpecifica.model().VERSIONE,true));
  813.         sqlQueryObjectGet.addSelectField("id_soggetto");
  814.         sqlQueryObjectGet.setANDLogicOperator(true);
  815.         sqlQueryObjectGet.addWhereCondition("id=?");

  816.         // Recupero _accordoServizioParteSpecifica
  817.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] searchParams_accordoServizioParteSpecifica = new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] {
  818.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject(tableId,Long.class)
  819.         };
  820.         List<Class<?>> listaFieldIdReturnType_accordoServizioParteSpecifica = new ArrayList<Class<?>>();
  821.         listaFieldIdReturnType_accordoServizioParteSpecifica.add(String.class);
  822.         listaFieldIdReturnType_accordoServizioParteSpecifica.add(String.class);
  823.         listaFieldIdReturnType_accordoServizioParteSpecifica.add(Integer.class);
  824.         listaFieldIdReturnType_accordoServizioParteSpecifica.add(Long.class);
  825.         org.openspcoop2.core.commons.search.IdAccordoServizioParteSpecifica id_accordoServizioParteSpecifica = null;
  826.         List<Object> listaFieldId_accordoServizioParteSpecifica = jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet.createSQLQuery(), jdbcProperties.isShowSql(),
  827.                 listaFieldIdReturnType_accordoServizioParteSpecifica, searchParams_accordoServizioParteSpecifica);
  828.         if(listaFieldId_accordoServizioParteSpecifica==null || listaFieldId_accordoServizioParteSpecifica.size()<=0){
  829.             if(throwNotFound){
  830.                 throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  831.             }
  832.         }
  833.         else{
  834.             // set _accordoServizioParteSpecifica
  835.             id_accordoServizioParteSpecifica = new org.openspcoop2.core.commons.search.IdAccordoServizioParteSpecifica();
  836.             id_accordoServizioParteSpecifica.setTipo((String)listaFieldId_accordoServizioParteSpecifica.get(0));
  837.             id_accordoServizioParteSpecifica.setNome((String)listaFieldId_accordoServizioParteSpecifica.get(1));
  838.             id_accordoServizioParteSpecifica.setVersione((Integer)listaFieldId_accordoServizioParteSpecifica.get(2));
  839.             Long idSoggettoFK = (Long) listaFieldId_accordoServizioParteSpecifica.get(3);
  840.             id_accordoServizioParteSpecifica.
  841.                 setIdErogatore(((IDBSoggettoServiceSearch)this.getServiceManager(connection, jdbcProperties, log).
  842.                         getSoggettoServiceSearch()).findId(idSoggettoFK, true));
  843.         }
  844.        
  845.         return id_accordoServizioParteSpecifica;
  846.        
  847.     }

  848.     @Override
  849.     public Long findTableId(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdAccordoServizioParteSpecifica id, boolean throwNotFound)
  850.             throws NotFoundException, ServiceException, NotImplementedException, Exception {
  851.    
  852.         return this.findIdAccordoServizioParteSpecifica(jdbcProperties,log,connection,sqlQueryObject,id,throwNotFound);
  853.            
  854.     }
  855.    
  856.     @Override
  857.     public List<List<Object>> nativeQuery(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject,
  858.                                             String sql,List<Class<?>> returnClassTypes,Object ... param) throws ServiceException,NotFoundException,NotImplementedException,Exception{
  859.        
  860.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.nativeQuery(jdbcProperties, log, connection, sqlQueryObject,
  861.                                                                                             sql,returnClassTypes,param);
  862.                                                        
  863.     }
  864.    
  865.     protected Long findIdAccordoServizioParteSpecifica(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, IdAccordoServizioParteSpecifica id, boolean throwNotFound) throws NotFoundException, ServiceException, NotImplementedException, Exception {

  866.         if(jdbcProperties==null) {
  867.             throw new ServiceException("Param jdbcProperties is null");
  868.         }
  869.         if(sqlQueryObject==null) {
  870.             throw new ServiceException("Param sqlQueryObject is null");
  871.         }
  872.         if(id==null) {
  873.             throw new ServiceException("Param id is null");
  874.         }
  875.        
  876.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities =
  877.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);

  878.         ISQLQueryObject sqlQueryObjectGet = sqlQueryObject.newSQLQueryObject();

  879.         if(id.getIdErogatore()==null){
  880.             throw new ServiceException("IdSoggettoErogatore non fornito");
  881.         }
  882.        
  883.         // Recupero id soggetto
  884.         ISoggettoServiceSearch soggettoServiceSearch = this.getServiceManager(connection, jdbcProperties, log).getSoggettoServiceSearch();
  885.         Soggetto accordo_id_referente_soggetto = ((IDBSoggettoServiceSearch)soggettoServiceSearch).get(id.getIdErogatore());
  886.            
  887.         // Object _accordoServizioParteSpecifica
  888.         sqlQueryObjectGet.addFromTable(this.getAccordoServizioParteSpecificaFieldConverter().toTable(AccordoServizioParteSpecifica.model()));
  889.         sqlQueryObjectGet.addSelectField("id");
  890.         sqlQueryObjectGet.setANDLogicOperator(true);
  891.         sqlQueryObjectGet.setSelectDistinct(true);
  892.         sqlQueryObjectGet.addWhereCondition(this.getAccordoServizioParteSpecificaFieldConverter().toColumn(AccordoServizioParteSpecifica.model().TIPO,true)+"=?");
  893.         sqlQueryObjectGet.addWhereCondition(this.getAccordoServizioParteSpecificaFieldConverter().toColumn(AccordoServizioParteSpecifica.model().NOME,true)+"=?");
  894.         sqlQueryObjectGet.addWhereCondition(this.getAccordoServizioParteSpecificaFieldConverter().toColumn(AccordoServizioParteSpecifica.model().VERSIONE,true)+"=?");
  895.         sqlQueryObjectGet.addWhereCondition("id_soggetto=?");

  896.         // Recupero _accordoServizioParteSpecifica
  897.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] searchParams_accordoServizioParteSpecifica = new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject [] {
  898.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject(id.getTipo(),String.class),
  899.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject(id.getNome(),String.class),
  900.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject(id.getVersione(),Integer.class),
  901.             new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject(accordo_id_referente_soggetto.getId(),Long.class)
  902.         };
  903.         Long id_accordoServizioParteSpecifica = null;
  904.         try{
  905.             id_accordoServizioParteSpecifica = (Long) jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet.createSQLQuery(), jdbcProperties.isShowSql(),
  906.                         Long.class, searchParams_accordoServizioParteSpecifica);
  907.         }catch(NotFoundException notFound){
  908.             if(throwNotFound){
  909.                 throw new NotFoundException(notFound);
  910.             }
  911.         }
  912.         if(id_accordoServizioParteSpecifica==null || id_accordoServizioParteSpecifica<=0){
  913.             if(throwNotFound){
  914.                 throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  915.             }
  916.         }
  917.        
  918.         return id_accordoServizioParteSpecifica;
  919.     }
  920. }