JDBCConfigurazioneRateLimitingProprietaServiceSearchImpl.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.controllo_traffico.dao.jdbc;

  22. import java.sql.Connection;
  23. import java.util.ArrayList;
  24. import java.util.List;
  25. import java.util.Map;

  27. import org.openspcoop2.core.controllo_traffico.ConfigurazioneRateLimitingProprieta;
  28. import org.openspcoop2.core.controllo_traffico.dao.jdbc.converter.ConfigurazioneRateLimitingProprietaFieldConverter;
  29. import org.openspcoop2.core.controllo_traffico.dao.jdbc.fetch.ConfigurazioneRateLimitingProprietaFetch;
  30. import org.openspcoop2.generic_project.beans.CustomField;
  31. import org.openspcoop2.generic_project.beans.FunctionField;
  32. import org.openspcoop2.generic_project.beans.IField;
  33. import org.openspcoop2.generic_project.beans.InUse;
  34. import org.openspcoop2.generic_project.beans.NonNegativeNumber;
  35. import org.openspcoop2.generic_project.beans.Union;
  36. import org.openspcoop2.generic_project.beans.UnionExpression;
  37. import org.openspcoop2.generic_project.dao.jdbc.IJDBCServiceSearchWithoutId;
  38. import org.openspcoop2.generic_project.dao.jdbc.JDBCExpression;
  39. import org.openspcoop2.generic_project.dao.jdbc.JDBCPaginatedExpression;
  40. import org.openspcoop2.generic_project.dao.jdbc.JDBCServiceManagerProperties;
  41. import org.openspcoop2.generic_project.dao.jdbc.utils.IJDBCFetch;
  42. import org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject;
  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.expression.impl.sql.ISQLFieldConverter;
  49. import org.openspcoop2.generic_project.utils.UtilsTemplate;
  50. import org.openspcoop2.utils.sql.ISQLQueryObject;
  51. import org.slf4j.Logger;

  53. /**     
  54.  * JDBCConfigurazioneRateLimitingProprietaServiceSearchImpl
  55.  *
  56.  * @author Poli Andrea (poli@link.it)
  57.  * @author $Author$
  58.  * @version $Rev$, $Date$
  59.  */
  60. public class JDBCConfigurazioneRateLimitingProprietaServiceSearchImpl implements IJDBCServiceSearchWithoutId<ConfigurazioneRateLimitingProprieta, JDBCServiceManager> {

  62.     private ConfigurazioneRateLimitingProprietaFieldConverter _configurazioneRateLimitingProprietaFieldConverter = null;
  63.     public ConfigurazioneRateLimitingProprietaFieldConverter getConfigurazioneRateLimitingProprietaFieldConverter() {
  64.         if(this._configurazioneRateLimitingProprietaFieldConverter==null){
  65.             this._configurazioneRateLimitingProprietaFieldConverter = new ConfigurazioneRateLimitingProprietaFieldConverter(this.jdbcServiceManager.getJdbcProperties().getDatabaseType());
  66.         }       
  67.         return this._configurazioneRateLimitingProprietaFieldConverter;
  68.     }
  69.     @Override
  70.     public ISQLFieldConverter getFieldConverter() {
  71.         return this.getConfigurazioneRateLimitingProprietaFieldConverter();
  72.     }
  73.     
  74.     private ConfigurazioneRateLimitingProprietaFetch configurazioneRateLimitingProprietaFetch = new ConfigurazioneRateLimitingProprietaFetch();
  75.     public ConfigurazioneRateLimitingProprietaFetch getConfigurazioneRateLimitingProprietaFetch() {
  76.         return this.configurazioneRateLimitingProprietaFetch;
  77.     }
  78.     @Override
  79.     public IJDBCFetch getFetch() {
  80.         return getConfigurazioneRateLimitingProprietaFetch();
  81.     }
  82.     
  83.     
  84.     private JDBCServiceManager jdbcServiceManager = null;

  86.     @Override
  87.     public void setServiceManager(JDBCServiceManager serviceManager) throws ServiceException{
  88.         this.jdbcServiceManager = serviceManager;
  89.     }
  90.     
  91.     @Override
  92.     public JDBCServiceManager getServiceManager() throws ServiceException{
  93.         return this.jdbcServiceManager;
  94.     }
  95.     

  97.     
  98.     
  99.     
  100.     
  101.     @Override
  102.     public List<ConfigurazioneRateLimitingProprieta> findAll(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCPaginatedExpression expression, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotImplementedException, ServiceException,Exception {

  104.         List<ConfigurazioneRateLimitingProprieta> list = new ArrayList<ConfigurazioneRateLimitingProprieta>();
  105.         
  106.         // TODO: implementazione non efficiente. 
  107.         // Per ottenere una implementazione efficiente:
  108.         // 1. Usare metodo select di questa classe indirizzando esattamente i field necessari
  109.         // 2. Usare metodo getConfigurazioneRateLimitingProprietaFetch() sul risultato della select per ottenere un oggetto ConfigurazioneRateLimitingProprieta
  110.         //    La fetch con la map inserirà nell'oggetto solo i valori estratti 

  112.         List<Long> ids = this.findAllTableIds(jdbcProperties, log, connection, sqlQueryObject, expression);
  113.         
  114.         for(Long id: ids) {
  115.             list.add(this.get(jdbcProperties, log, connection, sqlQueryObject, id, idMappingResolutionBehaviour));
  116.         }

  118.         return list;      
  119.         
  120.     }
  121.     
  122.     @Override
  123.     public ConfigurazioneRateLimitingProprieta find(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) 
  124.         throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException,Exception {

  126.         long id = this.findTableId(jdbcProperties, log, connection, sqlQueryObject, expression);
  127.         if(id>0){
  128.             return this.get(jdbcProperties, log, connection, sqlQueryObject, id, idMappingResolutionBehaviour);
  129.         }else{
  130.             throw new NotFoundException("Entry with id["+id+"] not found");
  131.         }
  132.         
  133.     }
  134.     
  135.     @Override
  136.     public NonNegativeNumber count(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression) throws NotImplementedException, ServiceException,Exception {
  137.         
  138.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareCount(jdbcProperties, log, connection, sqlQueryObject, expression,
  139.                                                 this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model());
  140.         
  141.         sqlQueryObject.addSelectCountField(this.getConfigurazioneRateLimitingProprietaFieldConverter().toTable(ConfigurazioneRateLimitingProprieta.model())+".id","tot",true);
  142.         
  143.         joinEngine(expression,sqlQueryObject);
  144.         
  145.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.count(jdbcProperties, log, connection, sqlQueryObject, expression,
  146.                                                                             this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model(),listaQuery);
  147.     }


  150.     @Override
  151.     public List<Object> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  152.                                                     JDBCPaginatedExpression paginatedExpression, IField field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  153.         return this.select(jdbcProperties, log, connection, sqlQueryObject,
  154.                                 paginatedExpression, false, field);
  155.     }
  156.     
  157.     @Override
  158.     public List<Object> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  159.                                                     JDBCPaginatedExpression paginatedExpression, boolean distinct, IField field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  160.         List<Map<String,Object>> map = 
  161.             this.select(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression, distinct, new IField[]{field});
  162.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.selectSingleObject(map);
  163.     }
  164.     
  165.     @Override
  166.     public List<Map<String,Object>> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  167.                                                     JDBCPaginatedExpression paginatedExpression, IField ... field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  168.         return this.select(jdbcProperties, log, connection, sqlQueryObject,
  169.                                 paginatedExpression, false, field);
  170.     }
  171.     
  172.     @Override
  173.     public List<Map<String,Object>> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  174.                                                     JDBCPaginatedExpression paginatedExpression, boolean distinct, IField ... field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  175.         
  176.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,paginatedExpression,field);
  177.         try{
  178.         
  179.             ISQLQueryObject sqlQueryObjectDistinct = 
  180.                         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSqlQueryObjectForSelectDistinct(distinct,sqlQueryObject, paginatedExpression, log,
  181.                                                 this.getConfigurazioneRateLimitingProprietaFieldConverter(), field);

  183.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression, sqlQueryObjectDistinct);
  184.             
  185.         }finally{
  186.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,paginatedExpression,field);
  187.         }
  188.     }

  190.     @Override
  191.     public Object aggregate(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  192.                                                     JDBCExpression expression, FunctionField functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  193.         Map<String,Object> map = 
  194.             this.aggregate(jdbcProperties, log, connection, sqlQueryObject, expression, new FunctionField[]{functionField});
  195.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.selectAggregateObject(map,functionField);
  196.     }
  197.     
  198.     @Override
  199.     public Map<String,Object> aggregate(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  200.                                                     JDBCExpression expression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {                                                   
  201.         
  202.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,expression,functionField);
  203.         try{
  204.             List<Map<String,Object>> list = selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression);
  205.             return list.get(0);
  206.         }finally{
  207.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,expression,functionField);
  208.         }
  209.     }

  211.     @Override
  212.     public List<Map<String,Object>> groupBy(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  213.                                                     JDBCExpression expression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  214.         
  215.         if(expression.getGroupByFields().isEmpty()){
  216.             throw new ServiceException("GroupBy conditions not found in expression");
  217.         }
  218.         
  219.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,expression,functionField);
  220.         try{
  221.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression);
  222.         }finally{
  223.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,expression,functionField);
  224.         }
  225.     }
  226.     

  228.     @Override
  229.     public List<Map<String,Object>> groupBy(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  230.                                                     JDBCPaginatedExpression paginatedExpression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  231.         
  232.         if(paginatedExpression.getGroupByFields().isEmpty()){
  233.             throw new ServiceException("GroupBy conditions not found in expression");
  234.         }
  235.         
  236.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,paginatedExpression,functionField);
  237.         try{
  238.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression);
  239.         }finally{
  240.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,paginatedExpression,functionField);
  241.         }
  242.     }
  243.     
  244.     protected List<Map<String,Object>> selectEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  245.                                                 IExpression expression) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  246.         return selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression, null);
  247.     }
  248.     protected List<Map<String,Object>> selectEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  249.                                                 IExpression expression, ISQLQueryObject sqlQueryObjectDistinct) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  250.         
  251.         List<Object> listaQuery = new ArrayList<>();
  252.         List<JDBCObject> listaParams = new ArrayList<>();
  253.         List<Object> returnField = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSelect(jdbcProperties, log, connection, sqlQueryObject, 
  254.                                 expression, this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model(), 
  255.                                 listaQuery,listaParams);
  256.         
  257.         joinEngine(expression,sqlQueryObject);
  258.         
  259.         List<Map<String,Object>> list = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.select(jdbcProperties, log, connection,
  260.                                         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSqlQueryObjectForSelectDistinct(sqlQueryObject,sqlQueryObjectDistinct), 
  261.                                         expression, this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model(),
  262.                                         listaQuery,listaParams,returnField);
  263.         if(list!=null && !list.isEmpty()){
  264.             return list;
  265.         }
  266.         else{
  267.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  268.         }
  269.     }
  270.     
  271.     @Override
  272.     public List<Map<String,Object>> union(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  273.                                                 Union union, UnionExpression ... unionExpression) throws ServiceException,NotFoundException,NotImplementedException,Exception {     
  274.         
  275.         List<ISQLQueryObject> sqlQueryObjectInnerList = new ArrayList<>();
  276.         List<JDBCObject> jdbcObjects = new ArrayList<>();
  277.         List<Class<?>> returnClassTypes = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareUnion(jdbcProperties, log, connection, sqlQueryObject, 
  278.                                 this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model(), 
  279.                                 sqlQueryObjectInnerList, jdbcObjects, union, unionExpression);
  280.         
  281.         if(unionExpression!=null){
  282.             for (int i = 0; i < unionExpression.length; i++) {
  283.                 UnionExpression ue = unionExpression[i];
  284.                 IExpression expression = ue.getExpression();
  285.                 joinEngine(expression,sqlQueryObjectInnerList.get(i));
  286.             }
  287.         }
  288.         
  289.         List<Map<String,Object>> list = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.union(jdbcProperties, log, connection, sqlQueryObject, 
  290.                                         this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model(), 
  291.                                         sqlQueryObjectInnerList, jdbcObjects, returnClassTypes, union, unionExpression);
  292.         if(list!=null && !list.isEmpty()){
  293.             return list;
  294.         }
  295.         else{
  296.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  297.         }                               
  298.     }
  299.     
  300.     @Override
  301.     public NonNegativeNumber unionCount(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  302.                                                 Union union, UnionExpression ... unionExpression) throws ServiceException,NotFoundException,NotImplementedException,Exception {     
  303.         
  304.         List<ISQLQueryObject> sqlQueryObjectInnerList = new ArrayList<>();
  305.         List<JDBCObject> jdbcObjects = new ArrayList<>();
  306.         List<Class<?>> returnClassTypes = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareUnionCount(jdbcProperties, log, connection, sqlQueryObject, 
  307.                                 this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model(), 
  308.                                 sqlQueryObjectInnerList, jdbcObjects, union, unionExpression);
  309.         
  310.         if(unionExpression!=null){
  311.             for (int i = 0; i < unionExpression.length; i++) {
  312.                 UnionExpression ue = unionExpression[i];
  313.                 IExpression expression = ue.getExpression();
  314.                 joinEngine(expression,sqlQueryObjectInnerList.get(i));
  315.             }
  316.         }
  317.         
  318.         NonNegativeNumber number = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.unionCount(jdbcProperties, log, connection, sqlQueryObject, 
  319.                                         this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model(), 
  320.                                         sqlQueryObjectInnerList, jdbcObjects, returnClassTypes, union, unionExpression);
  321.         if(number!=null && number.longValue()>=0){
  322.             return number;
  323.         }
  324.         else{
  325.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  326.         }
  327.     }



  331.     // -- ConstructorExpression 

  333.     @Override
  334.     public JDBCExpression newExpression(Logger log) throws NotImplementedException, ServiceException {
  335.         try{
  336.             return new JDBCExpression(this.getConfigurazioneRateLimitingProprietaFieldConverter());
  337.         }catch(Exception e){
  338.             throw new ServiceException(e);
  339.         }
  340.     }


  343.     @Override
  344.     public JDBCPaginatedExpression newPaginatedExpression(Logger log) throws NotImplementedException, ServiceException {
  345.         try{
  346.             return new JDBCPaginatedExpression(this.getConfigurazioneRateLimitingProprietaFieldConverter());
  347.         }catch(Exception e){
  348.             throw new ServiceException(e);
  349.         }
  350.     }
  351.     
  352.     @Override
  353.     public JDBCExpression toExpression(JDBCPaginatedExpression paginatedExpression, Logger log) throws NotImplementedException, ServiceException {
  354.         try{
  355.             return new JDBCExpression(paginatedExpression);
  356.         }catch(Exception e){
  357.             throw new ServiceException(e);
  358.         }
  359.     }

  361.     @Override
  362.     public JDBCPaginatedExpression toPaginatedExpression(JDBCExpression expression, Logger log) throws NotImplementedException, ServiceException {
  363.         try{
  364.             return new JDBCPaginatedExpression(expression);
  365.         }catch(Exception e){
  366.             throw new ServiceException(e);
  367.         }
  368.     }
  369.     
  370.     
  371.     
  372.     // -- DB

  374.     
  375.     @Override
  376.     public ConfigurazioneRateLimitingProprieta get(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException, Exception {
  377.         return this.getEngine(jdbcProperties, log, connection, sqlQueryObject, Long.valueOf(tableId), idMappingResolutionBehaviour);
  378.     }
  379.     
  380.     private ConfigurazioneRateLimitingProprieta getEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, Long tableId, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException, Exception {
  381.     
  382.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  383.                     new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  384.         
  385.         ISQLQueryObject sqlQueryObjectGet = sqlQueryObject.newSQLQueryObject();
  386.                 
  387.         ConfigurazioneRateLimitingProprieta configurazioneRateLimitingProprieta = new ConfigurazioneRateLimitingProprieta();
  388.         

  390.         // Object configurazioneRateLimitingProprieta
  391.         sqlQueryObjectGet.setANDLogicOperator(true);
  392.         sqlQueryObjectGet.addFromTable(this.getConfigurazioneRateLimitingProprietaFieldConverter().toTable(ConfigurazioneRateLimitingProprieta.model()));
  393.         sqlQueryObjectGet.addSelectField("id");
  394.         sqlQueryObjectGet.addSelectField(this.getConfigurazioneRateLimitingProprietaFieldConverter().toColumn(ConfigurazioneRateLimitingProprieta.model().NOME,true));
  395.         sqlQueryObjectGet.addSelectField(this.getConfigurazioneRateLimitingProprietaFieldConverter().toColumn(ConfigurazioneRateLimitingProprieta.model().VALORE,true));
  396.         sqlQueryObjectGet.addWhereCondition("id=?");

  398.         // Get configurazioneRateLimitingProprieta
  399.         configurazioneRateLimitingProprieta = (ConfigurazioneRateLimitingProprieta) jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet.createSQLQuery(), jdbcProperties.isShowSql(), ConfigurazioneRateLimitingProprieta.model(), this.getConfigurazioneRateLimitingProprietaFetch(),
  400.             new JDBCObject(tableId,Long.class));



  404.         
  405.         return configurazioneRateLimitingProprieta;  
  406.     
  407.     } 
  408.     
  409.     @Override
  410.     public boolean exists(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId) throws MultipleResultException, NotImplementedException, ServiceException, Exception {
  411.         return this._exists(jdbcProperties, log, connection, sqlQueryObject, Long.valueOf(tableId));
  412.     }
  413.     
  414.     private boolean _exists(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, Long tableId) throws MultipleResultException, NotImplementedException, ServiceException, Exception {
  415.     
  416.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  417.                     new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  418.                 
  419.         boolean existsConfigurazioneRateLimitingProprieta = false;

  421.         sqlQueryObject = sqlQueryObject.newSQLQueryObject();
  422.         sqlQueryObject.setANDLogicOperator(true);

  424.         sqlQueryObject.addFromTable(this.getConfigurazioneRateLimitingProprietaFieldConverter().toTable(ConfigurazioneRateLimitingProprieta.model()));
  425.         sqlQueryObject.addSelectField(this.getConfigurazioneRateLimitingProprietaFieldConverter().toColumn(ConfigurazioneRateLimitingProprieta.model().NOME,true));
  426.         sqlQueryObject.addWhereCondition("id=?");


  429.         // Exists configurazioneRateLimitingProprieta
  430.         existsConfigurazioneRateLimitingProprieta = jdbcUtilities.exists(sqlQueryObject.createSQLQuery(), jdbcProperties.isShowSql(),
  431.             new JDBCObject(tableId,Long.class));

  433.         
  434.         return existsConfigurazioneRateLimitingProprieta;
  435.     
  436.     }
  437.     
  438.     private void joinEngine(IExpression expression, ISQLQueryObject sqlQueryObject) throws NotImplementedException, ServiceException, Exception{
  439.     
  440.     }
  441.     
  442.     protected java.util.List<Object> getRootTablePrimaryKeyValuesEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, ConfigurazioneRateLimitingProprieta configurazioneRateLimitingProprieta) throws NotFoundException, ServiceException, NotImplementedException, Exception{
  443.         // Identificativi
  444.         java.util.List<Object> rootTableIdValues = new java.util.ArrayList<>();
  445.         rootTableIdValues.add(configurazioneRateLimitingProprieta.getId());
  446.                 
  447.         return rootTableIdValues;
  448.     }
  449.     
  450.     protected Map<String, List<IField>> getMapTableToPKColumnEngine() throws NotImplementedException, Exception{
  451.     
  452.         ConfigurazioneRateLimitingProprietaFieldConverter converter = this.getConfigurazioneRateLimitingProprietaFieldConverter();
  453.         Map<String, List<IField>> mapTableToPKColumn = new java.util.HashMap<>();
  454.         UtilsTemplate<IField> utilities = new UtilsTemplate<>();

  456.         // ConfigurazioneRateLimitingProprieta.model()
  457.         mapTableToPKColumn.put(converter.toTable(ConfigurazioneRateLimitingProprieta.model()),
  458.             utilities.newList(
  459.                 new CustomField("id", Long.class, "id", converter.toTable(ConfigurazioneRateLimitingProprieta.model()))
  460.             ));
  461.         
  462.         return mapTableToPKColumn;      
  463.     }
  464.     
  465.     @Override
  466.     public List<Long> findAllTableIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCPaginatedExpression paginatedExpression) throws ServiceException, NotImplementedException, Exception {
  467.         
  468.         List<Long> list = new ArrayList<Long>();

  470.         sqlQueryObject.setSelectDistinct(true);
  471.         sqlQueryObject.setANDLogicOperator(true);
  472.         sqlQueryObject.addSelectField(this.getConfigurazioneRateLimitingProprietaFieldConverter().toTable(ConfigurazioneRateLimitingProprieta.model())+".id");
  473.         Class<?> objectIdClass = Long.class;
  474.         
  475.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareFindAll(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression,
  476.                                                 this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model());
  477.         
  478.         joinEngine(paginatedExpression,sqlQueryObject);
  479.         
  480.         List<Object> listObjects = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.findAll(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression,
  481.                                                                             this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model(), objectIdClass, listaQuery);
  482.         for(Object object: listObjects) {
  483.             list.add((Long)object);
  484.         }

  486.         return list;
  487.         
  488.     }
  489.     
  490.     @Override
  491.     public long findTableId(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression) throws ServiceException, NotFoundException, MultipleResultException, NotImplementedException, Exception {
  492.     
  493.         sqlQueryObject.setSelectDistinct(true);
  494.         sqlQueryObject.setANDLogicOperator(true);
  495.         sqlQueryObject.addSelectField(this.getConfigurazioneRateLimitingProprietaFieldConverter().toTable(ConfigurazioneRateLimitingProprieta.model())+".id");
  496.         Class<?> objectIdClass = Long.class;
  497.         
  498.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareFind(jdbcProperties, log, connection, sqlQueryObject, expression,
  499.                                                 this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model());
  500.         
  501.         joinEngine(expression,sqlQueryObject);

  503.         Object res = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.find(jdbcProperties, log, connection, sqlQueryObject, expression,
  504.                                                         this.getConfigurazioneRateLimitingProprietaFieldConverter(), ConfigurazioneRateLimitingProprieta.model(), objectIdClass, listaQuery);
  505.         if(res!=null && (((Long) res).longValue()>0) ){
  506.             return ((Long) res).longValue();
  507.         }
  508.         else{
  509.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  510.         }
  511.         
  512.     }

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

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

  521.         InUse inUse = new InUse();
  522.         inUse.setInUse(false);
  523.         
  524.         /* 
  525.          * TODO: implement code that checks whether the object identified by the id parameter is used by other objects
  526.         */
  527.         
  528.         // Delete this line when you have implemented the method
  529.         int throwNotImplemented = 1;
  530.         if(throwNotImplemented==1){
  531.                 throw new NotImplementedException("NotImplemented");
  532.         }
  533.         // Delete this line when you have implemented the method

  535.         return inUse;

  537.     }
  538.     

  540.     
  541.     @Override
  542.     public List<List<Object>> nativeQuery(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  543.                                             String sql,List<Class<?>> returnClassTypes,Object ... param) throws ServiceException,NotFoundException,NotImplementedException,Exception{
  544.         
  545.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.nativeQuery(jdbcProperties, log, connection, sqlQueryObject,
  546.                                                                                             sql,returnClassTypes,param);
  547.                                                         
  548.     }
  549.     
  550. }
Created with JaCoCo 0.8.8.202204050719