JDBCEventoServiceSearchImpl.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.eventi.dao.jdbc;

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

  26. import java.sql.Connection;

  28. import org.slf4j.Logger;

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

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

  52. import org.openspcoop2.generic_project.dao.jdbc.JDBCServiceManagerProperties;
  53. import org.openspcoop2.core.eventi.dao.jdbc.converter.EventoFieldConverter;
  54. import org.openspcoop2.core.eventi.dao.jdbc.fetch.EventoFetch;
  55. import org.openspcoop2.core.eventi.Evento;

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

  66.     private EventoFieldConverter _eventoFieldConverter = null;
  67.     public EventoFieldConverter getEventoFieldConverter() {
  68.         if(this._eventoFieldConverter==null){
  69.             this._eventoFieldConverter = new EventoFieldConverter(this.jdbcServiceManager.getJdbcProperties().getDatabaseType());
  70.         }       
  71.         return this._eventoFieldConverter;
  72.     }
  73.     @Override
  74.     public ISQLFieldConverter getFieldConverter() {
  75.         return this.getEventoFieldConverter();
  76.     }
  77.     
  78.     private EventoFetch eventoFetch = new EventoFetch();
  79.     public EventoFetch getEventoFetch() {
  80.         return this.eventoFetch;
  81.     }
  82.     @Override
  83.     public IJDBCFetch getFetch() {
  84.         return getEventoFetch();
  85.     }
  86.     
  87.     
  88.     private JDBCServiceManager jdbcServiceManager = null;

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

  101.     
  102.     
  103.     private static boolean efficiente = true;
  104.     public static boolean isEfficiente() {
  105.         return efficiente;
  106.     }
  107.     public static void setEfficiente(boolean efficiente) {
  108.         JDBCEventoServiceSearchImpl.efficiente = efficiente;
  109.     }
  110.     @Override
  111.     public List<Evento> findAll(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCPaginatedExpression expression, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotImplementedException, ServiceException,Exception {

  113.         List<Evento> list = new ArrayList<Evento>();
  114.         
  115.         if(efficiente){
  116.             
  117.             List<IField> fields = new ArrayList<IField>();
  118.             fields.add(new CustomField("id", Long.class, "id", this.getEventoFieldConverter().toTable(Evento.model())));  
  119.             fields.add(Evento.model().TIPO);
  120.             fields.add(Evento.model().CODICE);
  121.             fields.add(Evento.model().SEVERITA);
  122.             fields.add(Evento.model().ORA_REGISTRAZIONE);
  123.             fields.add(Evento.model().DESCRIZIONE);
  124.             fields.add(Evento.model().ID_TRANSAZIONE);
  125.             fields.add(Evento.model().ID_CONFIGURAZIONE);
  126.             fields.add(Evento.model().CONFIGURAZIONE);
  127.             fields.add(Evento.model().CLUSTER_ID);
  128.                 
  129.             List<Map<String, Object>> returnMap = null;
  130.             try{
  131.                 boolean distinct = false; // e' piu' efficiente senza il distinct
  132.                 returnMap = this.select(jdbcProperties, log, connection, sqlQueryObject, expression, distinct, fields.toArray(new IField[1]));
  133.     
  134.                 for(Map<String, Object> map: returnMap) {
  135.                     list.add((Evento)this.getEventoFetch().fetch(jdbcProperties.getDatabase(), Evento.model(), map));
  136.                 }
  137.             }catch(NotFoundException notFound){}
  138.         }
  139.         else{

  141.             List<Long> ids = this.findAllTableIds(jdbcProperties, log, connection, sqlQueryObject, expression);
  142.             
  143.             for(Long id: ids) {
  144.                 list.add(this.get(jdbcProperties, log, connection, sqlQueryObject, id, idMappingResolutionBehaviour));
  145.             }
  146.             
  147.         }

  149.         return list;      
  150.         
  151.     }
  152.     
  153.     @Override
  154.     public Evento find(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) 
  155.         throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException,Exception {

  157.         long id = this.findTableId(jdbcProperties, log, connection, sqlQueryObject, expression);
  158.         if(id>0){
  159.             return this.get(jdbcProperties, log, connection, sqlQueryObject, id, idMappingResolutionBehaviour);
  160.         }else{
  161.             throw new NotFoundException("Entry with id["+id+"] not found");
  162.         }
  163.         
  164.     }
  165.     
  166.     @Override
  167.     public NonNegativeNumber count(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression) throws NotImplementedException, ServiceException,Exception {
  168.         
  169.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareCount(jdbcProperties, log, connection, sqlQueryObject, expression,
  170.                                                 this.getEventoFieldConverter(), Evento.model());
  171.         
  172.         boolean distinct = false; // e' piu' efficiente senza il distinct
  173.         if(!distinct && expression.inUseField(Evento.model().ORA_REGISTRAZIONE, true)){
  174.             // uso la prima colonna dell'indice (se c'è la data e non è distinct)
  175.             sqlQueryObject.addSelectCountField(this.getEventoFieldConverter().toColumn(Evento.model().ORA_REGISTRAZIONE, true),"tot",distinct);
  176.         }
  177.         else{
  178.             sqlQueryObject.addSelectCountField(this.getEventoFieldConverter().toTable(Evento.model())+".id","tot",distinct);
  179.         }
  180.         
  181.         joinEngine(expression,sqlQueryObject);
  182.         
  183.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.count(jdbcProperties, log, connection, sqlQueryObject, expression,
  184.                                                                             this.getEventoFieldConverter(), Evento.model(),listaQuery);
  185.     }


  188.     @Override
  189.     public List<Object> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  190.                                                     JDBCPaginatedExpression paginatedExpression, IField field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  191.         return this.select(jdbcProperties, log, connection, sqlQueryObject,
  192.                                 paginatedExpression, false, field);
  193.     }
  194.     
  195.     @Override
  196.     public List<Object> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  197.                                                     JDBCPaginatedExpression paginatedExpression, boolean distinct, IField field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  198.         List<Map<String,Object>> map = 
  199.             this.select(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression, distinct, new IField[]{field});
  200.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.selectSingleObject(map);
  201.     }
  202.     
  203.     @Override
  204.     public List<Map<String,Object>> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  205.                                                     JDBCPaginatedExpression paginatedExpression, IField ... field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  206.         return this.select(jdbcProperties, log, connection, sqlQueryObject,
  207.                                 paginatedExpression, false, field);
  208.     }
  209.     
  210.     @Override
  211.     public List<Map<String,Object>> select(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  212.                                                     JDBCPaginatedExpression paginatedExpression, boolean distinct, IField ... field) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  213.         
  214.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,paginatedExpression,field);
  215.         try{
  216.         
  217.             ISQLQueryObject sqlQueryObjectDistinct = 
  218.                         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSqlQueryObjectForSelectDistinct(distinct,sqlQueryObject, paginatedExpression, log,
  219.                                                 this.getEventoFieldConverter(), field);

  221.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression, sqlQueryObjectDistinct);
  222.             
  223.         }finally{
  224.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,paginatedExpression,field);
  225.         }
  226.     }

  228.     @Override
  229.     public Object aggregate(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  230.                                                     JDBCExpression expression, FunctionField functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  231.         Map<String,Object> map = 
  232.             this.aggregate(jdbcProperties, log, connection, sqlQueryObject, expression, new FunctionField[]{functionField});
  233.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.selectAggregateObject(map,functionField);
  234.     }
  235.     
  236.     @Override
  237.     public Map<String,Object> aggregate(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  238.                                                     JDBCExpression expression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {                                                   
  239.         
  240.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,expression,functionField);
  241.         try{
  242.             List<Map<String,Object>> list = selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression);
  243.             return list.get(0);
  244.         }finally{
  245.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,expression,functionField);
  246.         }
  247.     }

  249.     @Override
  250.     public List<Map<String,Object>> groupBy(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  251.                                                     JDBCExpression expression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  252.         
  253.         if(expression.getGroupByFields().isEmpty()){
  254.             throw new ServiceException("GroupBy conditions not found in expression");
  255.         }
  256.         
  257.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,expression,functionField);
  258.         try{
  259.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression);
  260.         }finally{
  261.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,expression,functionField);
  262.         }
  263.     }
  264.     

  266.     @Override
  267.     public List<Map<String,Object>> groupBy(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  268.                                                     JDBCPaginatedExpression paginatedExpression, FunctionField ... functionField) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  269.         
  270.         if(paginatedExpression.getGroupByFields().isEmpty()){
  271.             throw new ServiceException("GroupBy conditions not found in expression");
  272.         }
  273.         
  274.         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.setFields(sqlQueryObject,paginatedExpression,functionField);
  275.         try{
  276.             return selectEngine(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression);
  277.         }finally{
  278.             org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.removeFields(sqlQueryObject,paginatedExpression,functionField);
  279.         }
  280.     }
  281.     
  282.     protected List<Map<String,Object>> selectEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  283.                                                 IExpression expression) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  284.         return selectEngine(jdbcProperties, log, connection, sqlQueryObject, expression, null);
  285.     }
  286.     protected List<Map<String,Object>> selectEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  287.                                                 IExpression expression, ISQLQueryObject sqlQueryObjectDistinct) throws ServiceException,NotFoundException,NotImplementedException,Exception {
  288.         
  289.         List<Object> listaQuery = new ArrayList<>();
  290.         List<JDBCObject> listaParams = new ArrayList<>();
  291.         List<Object> returnField = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSelect(jdbcProperties, log, connection, sqlQueryObject, 
  292.                                 expression, this.getEventoFieldConverter(), Evento.model(), 
  293.                                 listaQuery,listaParams);
  294.         
  295.         joinEngine(expression,sqlQueryObject);
  296.         
  297.         List<Map<String,Object>> list = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.select(jdbcProperties, log, connection,
  298.                                         org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareSqlQueryObjectForSelectDistinct(sqlQueryObject,sqlQueryObjectDistinct), 
  299.                                         expression, this.getEventoFieldConverter(), Evento.model(),
  300.                                         listaQuery,listaParams,returnField);
  301.         if(list!=null && !list.isEmpty()){
  302.             return list;
  303.         }
  304.         else{
  305.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  306.         }
  307.     }
  308.     
  309.     @Override
  310.     public List<Map<String,Object>> union(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  311.                                                 Union union, UnionExpression ... unionExpression) throws ServiceException,NotFoundException,NotImplementedException,Exception {     
  312.         
  313.         List<ISQLQueryObject> sqlQueryObjectInnerList = new ArrayList<>();
  314.         List<JDBCObject> jdbcObjects = new ArrayList<>();
  315.         List<Class<?>> returnClassTypes = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareUnion(jdbcProperties, log, connection, sqlQueryObject, 
  316.                                 this.getEventoFieldConverter(), Evento.model(), 
  317.                                 sqlQueryObjectInnerList, jdbcObjects, union, unionExpression);
  318.         
  319.         if(unionExpression!=null){
  320.             for (int i = 0; i < unionExpression.length; i++) {
  321.                 UnionExpression ue = unionExpression[i];
  322.                 IExpression expression = ue.getExpression();
  323.                 joinEngine(expression,sqlQueryObjectInnerList.get(i));
  324.             }
  325.         }
  326.         
  327.         List<Map<String,Object>> list = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.union(jdbcProperties, log, connection, sqlQueryObject, 
  328.                                         this.getEventoFieldConverter(), Evento.model(), 
  329.                                         sqlQueryObjectInnerList, jdbcObjects, returnClassTypes, union, unionExpression);
  330.         if(list!=null && !list.isEmpty()){
  331.             return list;
  332.         }
  333.         else{
  334.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  335.         }                               
  336.     }
  337.     
  338.     @Override
  339.     public NonNegativeNumber unionCount(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  340.                                                 Union union, UnionExpression ... unionExpression) throws ServiceException,NotFoundException,NotImplementedException,Exception {     
  341.         
  342.         List<ISQLQueryObject> sqlQueryObjectInnerList = new ArrayList<>();
  343.         List<JDBCObject> jdbcObjects = new ArrayList<>();
  344.         List<Class<?>> returnClassTypes = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareUnionCount(jdbcProperties, log, connection, sqlQueryObject, 
  345.                                 this.getEventoFieldConverter(), Evento.model(), 
  346.                                 sqlQueryObjectInnerList, jdbcObjects, union, unionExpression);
  347.         
  348.         if(unionExpression!=null){
  349.             for (int i = 0; i < unionExpression.length; i++) {
  350.                 UnionExpression ue = unionExpression[i];
  351.                 IExpression expression = ue.getExpression();
  352.                 joinEngine(expression,sqlQueryObjectInnerList.get(i));
  353.             }
  354.         }
  355.         
  356.         NonNegativeNumber number = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.unionCount(jdbcProperties, log, connection, sqlQueryObject, 
  357.                                         this.getEventoFieldConverter(), Evento.model(), 
  358.                                         sqlQueryObjectInnerList, jdbcObjects, returnClassTypes, union, unionExpression);
  359.         if(number!=null && number.longValue()>=0){
  360.             return number;
  361.         }
  362.         else{
  363.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  364.         }
  365.     }



  369.     // -- ConstructorExpression 

  371.     @Override
  372.     public JDBCExpression newExpression(Logger log) throws NotImplementedException, ServiceException {
  373.         try{
  374.             return new JDBCExpression(this.getEventoFieldConverter());
  375.         }catch(Exception e){
  376.             throw new ServiceException(e);
  377.         }
  378.     }


  381.     @Override
  382.     public JDBCPaginatedExpression newPaginatedExpression(Logger log) throws NotImplementedException, ServiceException {
  383.         try{
  384.             return new JDBCPaginatedExpression(this.getEventoFieldConverter());
  385.         }catch(Exception e){
  386.             throw new ServiceException(e);
  387.         }
  388.     }
  389.     
  390.     @Override
  391.     public JDBCExpression toExpression(JDBCPaginatedExpression paginatedExpression, Logger log) throws NotImplementedException, ServiceException {
  392.         try{
  393.             return new JDBCExpression(paginatedExpression);
  394.         }catch(Exception e){
  395.             throw new ServiceException(e);
  396.         }
  397.     }

  399.     @Override
  400.     public JDBCPaginatedExpression toPaginatedExpression(JDBCExpression expression, Logger log) throws NotImplementedException, ServiceException {
  401.         try{
  402.             return new JDBCPaginatedExpression(expression);
  403.         }catch(Exception e){
  404.             throw new ServiceException(e);
  405.         }
  406.     }
  407.     
  408.     
  409.     
  410.     // -- DB

  412.     
  413.     @Override
  414.     public Evento get(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException, Exception {
  415.         return this.getEngine(jdbcProperties, log, connection, sqlQueryObject, Long.valueOf(tableId), idMappingResolutionBehaviour);
  416.     }
  417.     
  418.     private Evento getEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, Long tableId, org.openspcoop2.generic_project.beans.IDMappingBehaviour idMappingResolutionBehaviour) throws NotFoundException, MultipleResultException, NotImplementedException, ServiceException, Exception {
  419.     
  420.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  421.                     new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  422.         
  423.         ISQLQueryObject sqlQueryObjectGet = sqlQueryObject.newSQLQueryObject();
  424.                 
  425.         Evento evento = new Evento();
  426.         

  428.         // Object evento
  429.         ISQLQueryObject sqlQueryObjectGet_evento = sqlQueryObjectGet.newSQLQueryObject();
  430.         sqlQueryObjectGet_evento.setANDLogicOperator(true);
  431.         sqlQueryObjectGet_evento.addFromTable(this.getEventoFieldConverter().toTable(Evento.model()));
  432.         sqlQueryObjectGet_evento.addSelectField("id");
  433.         sqlQueryObjectGet_evento.addSelectField(this.getEventoFieldConverter().toColumn(Evento.model().TIPO,true));
  434.         sqlQueryObjectGet_evento.addSelectField(this.getEventoFieldConverter().toColumn(Evento.model().CODICE,true));
  435.         sqlQueryObjectGet_evento.addSelectField(this.getEventoFieldConverter().toColumn(Evento.model().SEVERITA,true));
  436.         sqlQueryObjectGet_evento.addSelectField(this.getEventoFieldConverter().toColumn(Evento.model().ORA_REGISTRAZIONE,true));
  437.         sqlQueryObjectGet_evento.addSelectField(this.getEventoFieldConverter().toColumn(Evento.model().DESCRIZIONE,true));
  438.         sqlQueryObjectGet_evento.addSelectField(this.getEventoFieldConverter().toColumn(Evento.model().ID_TRANSAZIONE,true));
  439.         sqlQueryObjectGet_evento.addSelectField(this.getEventoFieldConverter().toColumn(Evento.model().ID_CONFIGURAZIONE,true));
  440.         sqlQueryObjectGet_evento.addSelectField(this.getEventoFieldConverter().toColumn(Evento.model().CONFIGURAZIONE,true));
  441.         sqlQueryObjectGet_evento.addSelectField(this.getEventoFieldConverter().toColumn(Evento.model().CLUSTER_ID,true));
  442.         sqlQueryObjectGet_evento.addWhereCondition("id=?");

  444.         // Get evento
  445.         evento = (Evento) jdbcUtilities.executeQuerySingleResult(sqlQueryObjectGet_evento.createSQLQuery(), jdbcProperties.isShowSql(), Evento.model(), this.getEventoFetch(),
  446.             new JDBCObject(tableId,Long.class));



  450.         
  451.         return evento;  
  452.     
  453.     } 
  454.     
  455.     @Override
  456.     public boolean exists(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, long tableId) throws MultipleResultException, NotImplementedException, ServiceException, Exception {
  457.         return this._exists(jdbcProperties, log, connection, sqlQueryObject, Long.valueOf(tableId));
  458.     }
  459.     
  460.     private boolean _exists(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, Long tableId) throws MultipleResultException, NotImplementedException, ServiceException, Exception {
  461.     
  462.         org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities jdbcUtilities = 
  463.                     new org.openspcoop2.generic_project.dao.jdbc.utils.JDBCPreparedStatementUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2(), log, connection);
  464.                 
  465.         boolean existsEvento = false;

  467.         sqlQueryObject = sqlQueryObject.newSQLQueryObject();
  468.         sqlQueryObject.setANDLogicOperator(true);

  470.         sqlQueryObject.addFromTable(this.getEventoFieldConverter().toTable(Evento.model()));
  471.         sqlQueryObject.addSelectField(this.getEventoFieldConverter().toColumn(Evento.model().TIPO,true));
  472.         sqlQueryObject.addWhereCondition("id=?");


  475.         // Exists evento
  476.         existsEvento = jdbcUtilities.exists(sqlQueryObject.createSQLQuery(), jdbcProperties.isShowSql(),
  477.             new JDBCObject(tableId,Long.class));

  479.         
  480.         return existsEvento;
  481.     
  482.     }
  483.     
  484.     private void joinEngine(IExpression expression, ISQLQueryObject sqlQueryObject) throws NotImplementedException, ServiceException, Exception{
  485.     
  486.         // nop;
  487.         
  488.     }
  489.     
  490.     protected java.util.List<Object> getRootTablePrimaryKeyValuesEngine(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, Evento evento) throws NotFoundException, ServiceException, NotImplementedException, Exception{
  491.         // Identificativi
  492.         java.util.List<Object> rootTableIdValues = new java.util.ArrayList<>();
  493.         rootTableIdValues.add(evento.getId());
  494.                 
  495.         return rootTableIdValues;
  496.     }
  497.     
  498.     protected Map<String, List<IField>> getMapTableToPKColumnEngine() throws NotImplementedException, Exception{
  499.     
  500.         EventoFieldConverter converter = this.getEventoFieldConverter();
  501.         Map<String, List<IField>> mapTableToPKColumn = new java.util.HashMap<>();
  502.         UtilsTemplate<IField> utilities = new UtilsTemplate<>();

  504.         // Evento.model()
  505.         mapTableToPKColumn.put(converter.toTable(Evento.model()),
  506.             utilities.newList(
  507.                 new CustomField("id", Long.class, "id", converter.toTable(Evento.model()))
  508.             ));
  509.         
  510.         return mapTableToPKColumn;      
  511.     }
  512.     
  513.     @Override
  514.     public List<Long> findAllTableIds(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCPaginatedExpression paginatedExpression) throws ServiceException, NotImplementedException, Exception {
  515.         
  516.         List<Long> list = new ArrayList<Long>();

  518.         boolean distinct = false; // e' piu' efficiente senza il distinct
  519.         
  520.         sqlQueryObject.setSelectDistinct(distinct);
  521.         sqlQueryObject.setANDLogicOperator(true);
  522.         sqlQueryObject.addSelectField(this.getEventoFieldConverter().toTable(Evento.model())+".id");
  523.         Class<?> objectIdClass = Long.class;
  524.         
  525.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareFindAll(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression,
  526.                                                 this.getEventoFieldConverter(), Evento.model());
  527.         
  528.         joinEngine(paginatedExpression,sqlQueryObject);
  529.         
  530.         List<Object> listObjects = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.findAll(jdbcProperties, log, connection, sqlQueryObject, paginatedExpression,
  531.                                                                             this.getEventoFieldConverter(), Evento.model(), objectIdClass, listaQuery);
  532.         for(Object object: listObjects) {
  533.             list.add((Long)object);
  534.         }

  536.         return list;
  537.         
  538.     }
  539.     
  540.     @Override
  541.     public long findTableId(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, JDBCExpression expression) throws ServiceException, NotFoundException, MultipleResultException, NotImplementedException, Exception {
  542.     
  543.         boolean distinct = false; // e' piu' efficiente senza il distinct
  544.         
  545.         sqlQueryObject.setSelectDistinct(distinct);
  546.         sqlQueryObject.setANDLogicOperator(true);
  547.         sqlQueryObject.addSelectField(this.getEventoFieldConverter().toTable(Evento.model())+".id");
  548.         Class<?> objectIdClass = Long.class;
  549.         
  550.         List<Object> listaQuery = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.prepareFind(jdbcProperties, log, connection, sqlQueryObject, expression,
  551.                                                 this.getEventoFieldConverter(), Evento.model());
  552.         
  553.         joinEngine(expression,sqlQueryObject);

  555.         Object res = org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.find(jdbcProperties, log, connection, sqlQueryObject, expression,
  556.                                                         this.getEventoFieldConverter(), Evento.model(), objectIdClass, listaQuery);
  557.         if(res!=null && (((Long) res).longValue()>0) ){
  558.             return ((Long) res).longValue();
  559.         }
  560.         else{
  561.             throw org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.newNotFoundException();
  562.         }
  563.         
  564.     }

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

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

  573.         InUse inUse = new InUse();
  574.         inUse.setInUse(false);
  575.         
  576.         /* 
  577.          * TODO: implement code that checks whether the object identified by the id parameter is used by other objects
  578.         */
  579.         
  580.         // Delete this line when you have implemented the method
  581.         int throwNotImplemented = 1;
  582.         if(throwNotImplemented==1){
  583.                 throw new NotImplementedException("NotImplemented");
  584.         }
  585.         // Delete this line when you have implemented the method

  587.         return inUse;

  589.     }
  590.     

  592.     
  593.     @Override
  594.     public List<List<Object>> nativeQuery(JDBCServiceManagerProperties jdbcProperties, Logger log, Connection connection, ISQLQueryObject sqlQueryObject, 
  595.                                             String sql,List<Class<?>> returnClassTypes,Object ... param) throws ServiceException,NotFoundException,NotImplementedException,Exception{
  596.         
  597.         return org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCUtilities.nativeQuery(jdbcProperties, log, connection, sqlQueryObject,
  598.                                                                                             sql,returnClassTypes,param);
  599.                                                         
  600.     }
  601.     
  602. }
Created with JaCoCo 0.8.8.202204050719