RemoteStoreProviderDriverUtils.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.  */

  21. package org.openspcoop2.pdd.core.keystore;

  23. import java.sql.Connection;
  24. import java.sql.PreparedStatement;
  25. import java.sql.ResultSet;
  26. import java.sql.SQLException;
  27. import java.sql.Timestamp;
  28. import java.util.ArrayList;
  29. import java.util.Date;
  30. import java.util.List;

  32. import org.openspcoop2.core.commons.Filtri;
  33. import org.openspcoop2.core.commons.ISearch;
  34. import org.openspcoop2.core.commons.Liste;
  35. import org.openspcoop2.core.commons.SearchUtils;
  36. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  37. import org.openspcoop2.core.constants.CostantiDB;
  38. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  39. import org.openspcoop2.pdd.config.PDNDConfigUtilities;
  40. import org.openspcoop2.pdd.config.PDNDResolver;
  41. import org.openspcoop2.utils.TipiDatabase;
  42. import org.openspcoop2.utils.UtilsException;
  43. import org.openspcoop2.utils.certificate.remote.RemoteStoreClientInfo;
  44. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  45. import org.openspcoop2.utils.date.DateManager;
  46. import org.openspcoop2.utils.date.DateUtils;
  47. import org.openspcoop2.utils.jdbc.CustomKeyGeneratorObject;
  48. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  49. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKey;
  50. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKeyJDBCType;
  51. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKeyObject;
  52. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  53. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  54. import org.openspcoop2.utils.json.JsonPathExpressionEngine;
  55. import org.openspcoop2.utils.sql.ISQLQueryObject;
  56. import org.openspcoop2.utils.sql.LikeConfig;
  57. import org.openspcoop2.utils.sql.SQLObjectFactory;
  58. import org.openspcoop2.utils.sql.SQLQueryObjectException;
  59. import org.slf4j.Logger;

  61. /**
  62.  * RemoteStoreProviderDriverUtils
  63.  *
  64.  * @author Poli Andrea (apoli@link.it)
  65.  * @author $Author$
  66.  * @version $Rev$, $Date$
  67.  */
  68. public class RemoteStoreProviderDriverUtils {
  69.     
  70.     private RemoteStoreProviderDriverUtils() {}

  72.     private static final String COLUMN_ID = "id";
  73.     private static final String COLUMN_NOME = "nome";
  74.     private static final String COLUMN_DATA_REGISTRAZIONE = "data_registrazione";
  75.     private static final String COLUMN_DATA_AGGIORNAMENTO = "data_aggiornamento";
  76.     private static final String COLUMN_LAST_EVENT = "last_event";
  77.     
  78.     private static final String COLUMN_ID_REMOTE_STORE = "id_remote_store";
  79.     private static final String COLUMN_KID = "kid";
  80.     private static final String COLUMN_KEY = "content_key";
  81.     
  82.     private static final String COLUMN_CLIENT_ID = "client_id";
  83.     private static final String COLUMN_CLIENT_DETAILS = "client_details";
  84.     private static final String COLUMN_ORGANIZATION_DETAILS = "organization_details";
  85.     private static final String COLUMN_CLIENT_DATA_AGGIORNAMENTO = "client_data_aggiornamento";
  86.     
  87.     private static final String SUFFIX_NOT_FOUND = " not found";
  88.     
  89.     public static long registerIfNotExistsRemoteStore(DriverConfigurazioneDB driverConfigurazioneDB, RemoteStoreConfig remoteStoreConfig) throws KeystoreException {
  90.         long idRemoteStore = getIdRemoteStore(driverConfigurazioneDB, remoteStoreConfig);
  91.         if(idRemoteStore<=0) {
  92.             return createRemoteStore(driverConfigurazioneDB, remoteStoreConfig);
  93.         }
  94.         return idRemoteStore;
  95.     }
  96.     public static long registerIfNotExistsRemoteStore(Connection con, String tipoDatabase, RemoteStoreConfig remoteStoreConfig) throws KeystoreException {
  97.         long idRemoteStore = getIdRemoteStore(con, tipoDatabase, remoteStoreConfig);
  98.         if(idRemoteStore<=0) {
  99.             return createRemoteStore(con, tipoDatabase, remoteStoreConfig);
  100.         }
  101.         return idRemoteStore;
  102.     }
  103.     
  104.     public static long createRemoteStore(DriverConfigurazioneDB driverConfigurazioneDB, RemoteStoreConfig remoteStoreConfig) throws KeystoreException {
  105.         
  106.         Connection con = null;
  107.         try {
  108.             con = driverConfigurazioneDB.getConnection("createRemoteStore");
  109.             return createRemoteStore(con, driverConfigurazioneDB.getTipoDB(), remoteStoreConfig);
  110.         }
  111.         catch(Exception e) {
  112.             throw new KeystoreException(e.getMessage(),e);
  113.         }
  114.         finally {
  115.             driverConfigurazioneDB.releaseConnection(con);
  116.         }
  117.         
  118.     }
  119.     public static long createRemoteStore(Connection con, String tipoDatabase, RemoteStoreConfig remoteStoreConfig) throws KeystoreException {
  120.         
  121.         try {
  122.             String remoteStoreName = RemoteStoreProviderDriver.getRemoteStoreConfigName(remoteStoreConfig);
  123.             
  124.             Timestamp now = DateManager.getTimestamp();
  125.             
  126.             List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  127.             listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject(COLUMN_NOME, remoteStoreName, InsertAndGeneratedKeyJDBCType.STRING) );
  128.             listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject(COLUMN_DATA_AGGIORNAMENTO, now, InsertAndGeneratedKeyJDBCType.TIMESTAMP) );
  129.             
  130.             long idRemoteStore = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(tipoDatabase), 
  131.                     new CustomKeyGeneratorObject(CostantiDB.REMOTE_STORE, CostantiDB.REMOTE_STORE_COLUMN_ID, 
  132.                             CostantiDB.REMOTE_STORE_SEQUENCE, CostantiDB.REMOTE_STORE_TABLE_FOR_ID),
  133.                     listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  134.             if(idRemoteStore<=0){
  135.                 throw new KeystoreException("ID (RemoteStore) autoincrementale non ottenuto");
  136.             }
  137.             return idRemoteStore;
  138.         }
  139.         catch(Exception e) {
  140.             throw new KeystoreException(e.getMessage(),e);
  141.         }
  142.         
  143.     }
  144.     
  145.     public static long getIdRemoteStore(DriverConfigurazioneDB driverConfigurazioneDB, RemoteStoreConfig remoteStoreConfig) throws KeystoreException {
  146.         Connection con = null;
  147.         try {
  148.             con = driverConfigurazioneDB.getConnection("getIdRemoteStore");
  149.             return getIdRemoteStore(con, driverConfigurazioneDB.getTipoDB(), remoteStoreConfig);
  150.         }
  151.         catch(Exception e) {
  152.             throw new KeystoreException(e.getMessage(),e);
  153.         }
  154.         finally {
  155.             driverConfigurazioneDB.releaseConnection(con);
  156.         }
  157.     }
  158.     public static long getIdRemoteStore(Connection con, String tipoDatabase, RemoteStoreConfig remoteStoreConfig) throws KeystoreException {
  159.         
  160.         PreparedStatement selectStmt = null;
  161.         ResultSet selectRS = null;
  162.         long idRemoteStore = -1;
  163.         try {
  164.             String remoteStoreName = RemoteStoreProviderDriver.getRemoteStoreConfigName(remoteStoreConfig);
  165.             
  166.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  167.             sqlQueryObject.addFromTable(CostantiDB.REMOTE_STORE);
  168.             sqlQueryObject.addSelectField(COLUMN_ID);
  169.             sqlQueryObject.addWhereCondition(COLUMN_NOME+"=?");
  170.             sqlQueryObject.setANDLogicOperator(true);
  171.             String sqlQuery = sqlQueryObject.createSQLQuery();
  172.             selectStmt = con.prepareStatement(sqlQuery);
  173.             selectStmt.setString(1, remoteStoreName);
  174.             selectRS = selectStmt.executeQuery();
  175.             if(selectRS.next()) {
  176.                 idRemoteStore = selectRS.getLong(COLUMN_ID);
  177.             }
  178.         }
  179.         catch(Exception e) {
  180.             throw new KeystoreException(e.getMessage(),e);
  181.         }
  182.         finally {
  183.             
  184.             JDBCUtilities.closeResources(selectRS, selectStmt);
  185.         }
  186.         
  187.         return idRemoteStore;
  188.     }
  189.     
  190.     
  191.     
  192.     
  193.     public static RemoteStore getRemoteStore(DriverConfigurazioneDB driverConfigurazioneDB, RemoteStoreConfig remoteStoreConfig, boolean throwExceptionNotFound) throws KeystoreException {
  194.         Connection con = null;
  195.         try {
  196.             con = driverConfigurazioneDB.getConnection("getRemoteStore");
  197.             return getRemoteStore(con, driverConfigurazioneDB.getTipoDB(), remoteStoreConfig, throwExceptionNotFound);
  198.         }
  199.         catch(Exception e) {
  200.             throw new KeystoreException(e.getMessage(),e);
  201.         }
  202.         finally {
  203.             driverConfigurazioneDB.releaseConnection(con);
  204.         }
  205.     }
  206.     public static RemoteStore getRemoteStore(Connection con, String tipoDatabase, RemoteStoreConfig remoteStoreConfig, boolean throwExceptionNotFound) throws KeystoreException {
  207.         
  208.         PreparedStatement selectStmt = null;
  209.         ResultSet selectRS = null;
  210.         RemoteStore remoteStore = null;
  211.         try {
  212.             String remoteStoreName = RemoteStoreProviderDriver.getRemoteStoreConfigName(remoteStoreConfig);
  213.             
  214.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  215.             sqlQueryObject.addFromTable(CostantiDB.REMOTE_STORE);
  216.             sqlQueryObject.addSelectField("*");
  217.             sqlQueryObject.addWhereCondition(COLUMN_NOME+"=?");
  218.             sqlQueryObject.setANDLogicOperator(true);
  219.             String sqlQuery = sqlQueryObject.createSQLQuery();
  220.             selectStmt = con.prepareStatement(sqlQuery);
  221.             selectStmt.setString(1, remoteStoreName);
  222.             selectRS = selectStmt.executeQuery();
  223.             if(selectRS.next()) {
  224.                 remoteStore = new RemoteStore();
  225.                 remoteStore.setId(selectRS.getLong(COLUMN_ID));
  226.                 remoteStore.setDataAggiornamento(selectRS.getTimestamp(COLUMN_DATA_AGGIORNAMENTO));
  227.                 remoteStore.setLastEvent(selectRS.getString(COLUMN_LAST_EVENT));
  228.                 remoteStore.setNome(selectRS.getString(COLUMN_NOME));
  229.             }
  230.             else if(throwExceptionNotFound){
  231.                 throw new KeystoreException("RemoteStore '"+remoteStoreName+"'"+SUFFIX_NOT_FOUND);
  232.             }
  233.         }
  234.         catch(Exception e) {
  235.             throw new KeystoreException(e.getMessage(),e);
  236.         }
  237.         finally {
  238.             
  239.             JDBCUtilities.closeResources(selectRS, selectStmt);
  240.         }
  241.         
  242.         return remoteStore;
  243.     }
  244.     
  245.     
  246.     public static int updateRemoteStore(DriverConfigurazioneDB driverConfigurazioneDB, long idStore, String lastEventId) throws KeystoreException {
  247.         Connection con = null;
  248.         try {
  249.             con = driverConfigurazioneDB.getConnection("updateRemoteStore");
  250.             return updateRemoteStore(con, driverConfigurazioneDB.getTipoDB(), idStore, lastEventId);
  251.         }
  252.         catch(Exception e) {
  253.             throw new KeystoreException(e.getMessage(),e);
  254.         }
  255.         finally {
  256.             driverConfigurazioneDB.releaseConnection(con);
  257.         }
  258.     }
  259.     public static int updateRemoteStore(Connection con, String tipoDatabase, long idStore, String lastEventId) throws KeystoreException {
  260.         PreparedStatement updateStmt = null;
  261.         try {
  262.             checkRemoteStoreParams(idStore, lastEventId);
  263.             
  264.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  265.             sqlQueryObject.addUpdateTable(CostantiDB.REMOTE_STORE);
  266.             sqlQueryObject.addUpdateField(COLUMN_LAST_EVENT, "?");
  267.             sqlQueryObject.addUpdateField(COLUMN_DATA_AGGIORNAMENTO, "?");
  268.             sqlQueryObject.addWhereCondition(COLUMN_ID+"=?");
  269.             sqlQueryObject.setANDLogicOperator(true);
  270.             String updateQuery = sqlQueryObject.createSQLUpdate();
  271.             updateStmt = con.prepareStatement(updateQuery);
  272.             int index = 1;
  273.             Timestamp now = DateManager.getTimestamp();
  274.             updateStmt.setString(index++, lastEventId);
  275.             updateStmt.setTimestamp(index++, now);
  276.             updateStmt.setLong(index++, idStore);
  277.             int rows = updateStmt.executeUpdate();
  278.             updateStmt.close();
  279.             return rows;
  280.         }
  281.         catch(Exception e) {
  282.             throw new KeystoreException(e.getMessage(),e);
  283.         }
  284.         finally {   
  285.             JDBCUtilities.closeResources(updateStmt);
  286.         }
  287.     }
  288.     private static void checkRemoteStoreParams(long idStore, String lastEventId) throws KeystoreException {
  289.         if(idStore<=0) {
  290.             throw new KeystoreException("IdStore undefined");
  291.         }
  292.         if(lastEventId==null) {
  293.             throw new KeystoreException("LastEventId undefined");
  294.         }
  295.     }
  296.     
  297.     
  298.     public static List<RemoteStore> getRemoteStores(DriverConfigurazioneDB driverConfigurazioneDB) throws KeystoreException {
  299.         Connection con = null;
  300.         try {
  301.             con = driverConfigurazioneDB.getConnection("getRemoteStores");
  302.             return getRemoteStores(con, driverConfigurazioneDB.getTipoDB());
  303.         }
  304.         catch(Exception e) {
  305.             throw new KeystoreException(e.getMessage(),e);
  306.         }
  307.         finally {
  308.             driverConfigurazioneDB.releaseConnection(con);
  309.         }
  310.     }
  311.     public static List<RemoteStore> getRemoteStores(Connection con, String tipoDatabase) throws KeystoreException {
  312.         
  313.         List<RemoteStore> list = new ArrayList<>();
  314.         PreparedStatement selectStmt = null;
  315.         ResultSet selectRS = null;
  316.         try {
  317.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  318.             sqlQueryObject.addFromTable(CostantiDB.REMOTE_STORE);
  319.             sqlQueryObject.setANDLogicOperator(true);
  320.             sqlQueryObject.addOrderBy(COLUMN_NOME);
  321.             String sqlQuery = sqlQueryObject.createSQLQuery();
  322.             selectStmt = con.prepareStatement(sqlQuery);
  323.             selectRS = selectStmt.executeQuery();
  324.             while(selectRS.next()) {
  325.                 long idRemoteStore = selectRS.getLong(COLUMN_ID);
  326.                 Date dataAggiornamento = selectRS.getTimestamp(COLUMN_DATA_AGGIORNAMENTO);
  327.                 String lastEvent =  selectRS.getString(COLUMN_LAST_EVENT);
  328.                 String nome = selectRS.getString(COLUMN_NOME);
  329.                 RemoteStore rs = new RemoteStore();
  330.                 rs.setId(idRemoteStore);
  331.                 rs.setDataAggiornamento(dataAggiornamento);
  332.                 rs.setLastEvent(lastEvent);
  333.                 rs.setNome(nome);
  334.                 list.add(rs);
  335.             }
  336.         }
  337.         catch(Exception e) {
  338.             throw new KeystoreException(e.getMessage(),e);
  339.         }
  340.         finally {
  341.             
  342.             JDBCUtilities.closeResources(selectRS, selectStmt);
  343.         }
  344.         
  345.         return list;
  346.     }
  347.     
  348.     
  349.     
  350.     
  351.     
  352.     
  353.     public static int addRemoteStoreKey(DriverConfigurazioneDB driverConfigurazioneDB, long idStore, String kid, byte[] key) throws KeystoreException {
  354.         Connection con = null;
  355.         PreparedStatement updateStmt = null;
  356.         try {
  357.             con = driverConfigurazioneDB.getConnection("addRemoteStoreKey");
  358.             
  359.             checkParams(idStore, kid, key);
  360.             
  361.             IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(driverConfigurazioneDB.getTipoDB());
  362.             
  363.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(driverConfigurazioneDB.getTipoDB());
  364.             sqlQueryObject.addInsertTable(CostantiDB.REMOTE_STORE_KEY);
  365.             sqlQueryObject.addInsertField(COLUMN_ID_REMOTE_STORE, "?");
  366.             sqlQueryObject.addInsertField(COLUMN_KID, "?");
  367.             sqlQueryObject.addInsertField(COLUMN_KEY, "?");
  368.             sqlQueryObject.addInsertField(COLUMN_DATA_REGISTRAZIONE, "?");
  369.             sqlQueryObject.addInsertField(COLUMN_DATA_AGGIORNAMENTO, "?");
  370.             String updateQuery = sqlQueryObject.createSQLInsert();
  371.             updateStmt = con.prepareStatement(updateQuery);
  372.             int index = 1;
  373.             updateStmt.setLong(index++, idStore);
  374.             updateStmt.setString(index++, kid);
  375.             jdbcAdapter.setBinaryData(updateStmt, index++, key);
  376.             Timestamp now = DateManager.getTimestamp();
  377.             updateStmt.setTimestamp(index++, now);
  378.             updateStmt.setTimestamp(index++, now);
  379.             int rows = updateStmt.executeUpdate();
  380.             updateStmt.close();
  381.             return rows;
  382.         }
  383.         catch(Exception e) {
  384.             throw new KeystoreException(e.getMessage(),e);
  385.         }
  386.         finally {
  387.             
  388.             JDBCUtilities.closeResources(updateStmt);
  389.             
  390.             driverConfigurazioneDB.releaseConnection(con);
  391.         }
  392.     }
  393.     
  394.     public static int invalidRemoteStoreKey(DriverConfigurazioneDB driverConfigurazioneDB, long idStore, String kid) throws KeystoreException {
  395.         return updateRemoteStoreKeyEngine(driverConfigurazioneDB, idStore, kid, null, true);
  396.     }
  397.     public static int invalidRemoteStoreKey(Connection con, String tipoDatabase, long idStore, String kid) throws KeystoreException {
  398.         return updateRemoteStoreKeyEngine(con, tipoDatabase, idStore, kid, null, true);
  399.     }
  400.     public static int updateRemoteStoreKey(DriverConfigurazioneDB driverConfigurazioneDB, long idStore, String kid, byte[] key) throws KeystoreException {
  401.         return updateRemoteStoreKeyEngine(driverConfigurazioneDB, idStore, kid, key, false);
  402.     }
  403.     private static Timestamp dataInvalidaScaduta = null;
  404.     static{
  405.         try {
  406.             dataInvalidaScaduta = new Timestamp(DateUtils.getSimpleDateFormatDay().parse("2000-01-01").getTime());
  407.         }catch(Exception e) {
  408.             // ignore
  409.         }
  410.     }
  411.     private static int updateRemoteStoreKeyEngine(DriverConfigurazioneDB driverConfigurazioneDB, long idStore, String kid, byte[] key, boolean invalid) throws KeystoreException {
  412.         Connection con = null;
  413.         try {
  414.             con = driverConfigurazioneDB.getConnection(invalid ? "invalidRemoteStoreKey" : "updateRemoteStoreKey");
  415.             return updateRemoteStoreKeyEngine(con, driverConfigurazioneDB.getTipoDB(), idStore, kid, key, invalid);
  416.         }
  417.         catch(Exception e) {
  418.             throw new KeystoreException(e.getMessage(),e);
  419.         }
  420.         finally {
  421.             driverConfigurazioneDB.releaseConnection(con);
  422.         }
  423.     }
  424.     private static int updateRemoteStoreKeyEngine(Connection con, String tipoDatabase, long idStore, String kid, byte[] key, boolean invalid) throws KeystoreException {
  425.         PreparedStatement updateStmt = null;
  426.         try {
  427.             if(invalid) {
  428.                 checkParams(idStore, kid);  
  429.             }
  430.             else {
  431.                 checkParams(idStore, kid, key);
  432.             }
  433.             
  434.             IJDBCAdapter jdbcAdapter = null;
  435.             
  436.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  437.             sqlQueryObject.addUpdateTable(CostantiDB.REMOTE_STORE_KEY);
  438.             if(!invalid) {
  439.                 sqlQueryObject.addUpdateField(COLUMN_KEY, "?");
  440.                 jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(tipoDatabase);
  441.             }
  442.             sqlQueryObject.addUpdateField(COLUMN_DATA_AGGIORNAMENTO, "?");
  443.             if(invalid) {
  444.                 sqlQueryObject.addUpdateField(COLUMN_CLIENT_DATA_AGGIORNAMENTO, "?");
  445.             }
  446.             addWhereKidConditions(sqlQueryObject);
  447.             sqlQueryObject.setANDLogicOperator(true);
  448.             String updateQuery = sqlQueryObject.createSQLUpdate();
  449.             updateStmt = con.prepareStatement(updateQuery);
  450.             int index = 1;
  451.             Timestamp now = DateManager.getTimestamp();
  452.             if(invalid) {
  453.                 updateStmt.setTimestamp(index++, dataInvalidaScaduta);
  454.                 updateStmt.setTimestamp(index++, dataInvalidaScaduta);
  455.             }
  456.             else {
  457.                 jdbcAdapter.setBinaryData(updateStmt, index++, key);
  458.                 updateStmt.setTimestamp(index++, now);
  459.             }
  460.             updateStmt.setLong(index++, idStore);
  461.             updateStmt.setString(index++, kid);
  462.             int rows = updateStmt.executeUpdate();
  463.             updateStmt.close();
  464.             return rows;
  465.         }
  466.         catch(Exception e) {
  467.             throw new KeystoreException(e.getMessage(),e);
  468.         }
  469.         finally {
  470.             JDBCUtilities.closeResources(updateStmt);
  471.         }
  472.     }
  473.     
  474.     public static int deleteRemoteStoreKey(DriverConfigurazioneDB driverConfigurazioneDB, long idStore, String kid) throws KeystoreException {
  475.         Connection con = null;
  476.         try {
  477.             con = driverConfigurazioneDB.getConnection("deleteRemoteStoreKey");
  478.             return deleteRemoteStoreKey(con, driverConfigurazioneDB.getTipoDB(), idStore, kid);
  479.         }
  480.         catch(Exception e) {
  481.             throw new KeystoreException(e.getMessage(),e);
  482.         }
  483.         finally {
  484.             driverConfigurazioneDB.releaseConnection(con);
  485.         }
  486.     }
  487.     public static int deleteRemoteStoreKey(Connection con, String tipoDatabase, long idStore, String kid) throws KeystoreException {
  488.         PreparedStatement updateStmt = null;
  489.         try {
  490.             checkParams(idStore, kid);
  491.             
  492.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  493.             sqlQueryObject.addDeleteTable(CostantiDB.REMOTE_STORE_KEY);
  494.             addWhereKidConditions(sqlQueryObject);
  495.             sqlQueryObject.setANDLogicOperator(true);
  496.             String updateQuery = sqlQueryObject.createSQLDelete();
  497.             updateStmt = con.prepareStatement(updateQuery);
  498.             updateStmt.setLong(1, idStore);
  499.             updateStmt.setString(2, kid);
  500.             int rows = updateStmt.executeUpdate();
  501.             updateStmt.close();
  502.             return rows;
  503.         }
  504.         catch(Exception e) {
  505.             throw new KeystoreException(e.getMessage(),e);
  506.         }
  507.         finally {
  508.             JDBCUtilities.closeResources(updateStmt);
  509.         }
  510.     }
  511.     
  512.     public static RemoteStoreKey getRemoteStoreKey(DriverConfigurazioneDB driverConfigurazioneDB, long idStore, String kid) throws KeystoreException,KeystoreNotFoundException {
  513.         
  514.         Connection con = null;
  515.         PreparedStatement selectStmt = null;
  516.         ResultSet selectRS = null;
  517.         try {
  518.             con = driverConfigurazioneDB.getConnection("getRemoteStoreKey");
  519.             
  520.             checkParams(idStore, kid);
  521.             
  522.             IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(driverConfigurazioneDB.getTipoDB());
  523.             
  524.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(driverConfigurazioneDB.getTipoDB());
  525.             sqlQueryObject.addFromTable(CostantiDB.REMOTE_STORE_KEY);
  526.             sqlQueryObject.addSelectField(COLUMN_KEY);
  527.             sqlQueryObject.addSelectField(COLUMN_DATA_AGGIORNAMENTO);
  528.             addWhereKidConditions(sqlQueryObject);
  529.             sqlQueryObject.setANDLogicOperator(true);
  530.             String sqlQuery = sqlQueryObject.createSQLQuery();
  531.             selectStmt = con.prepareStatement(sqlQuery);
  532.             selectStmt.setLong(1, idStore);
  533.             selectStmt.setString(2, kid);
  534.             selectRS = selectStmt.executeQuery();
  535.             if(selectRS.next()) {
  536.                 RemoteStoreKey rsk = new RemoteStoreKey();
  537.                 rsk.setKey(jdbcAdapter.getBinaryData(selectRS, COLUMN_KEY));
  538.                 rsk.setDataAggiornamento(selectRS.getTimestamp(COLUMN_DATA_AGGIORNAMENTO));
  539.                 rsk.setInvalid(dataInvalidaScaduta.equals(rsk.getDataAggiornamento()));
  540.                 return rsk;
  541.             }
  542.             throw new KeystoreNotFoundException("Key with kid '"+kid+"'"+SUFFIX_NOT_FOUND);
  543.         }
  544.         catch(KeystoreNotFoundException e) {
  545.             throw e;
  546.         }
  547.         catch(Exception e) {
  548.             throw new KeystoreException(e.getMessage(),e);
  549.         }
  550.         finally {
  551.             
  552.             JDBCUtilities.closeResources(selectRS, selectStmt);
  553.             
  554.             driverConfigurazioneDB.releaseConnection(con);
  555.         }
  556.         
  557.     }
  558.     
  559.     public static boolean existsRemoteStoreKey(DriverConfigurazioneDB driverConfigurazioneDB, long idStore, String kid, boolean checkDates) throws KeystoreException {
  560.         
  561.         Connection con = null;
  562.         try {
  563.             con = driverConfigurazioneDB.getConnection("existsRemoteStoreKey");
  564.             return existsRemoteStoreKey(con, driverConfigurazioneDB.getTipoDB(), idStore, kid, checkDates);
  565.         }
  566.         catch(Exception e) {
  567.             throw new KeystoreException(e.getMessage(),e);
  568.         }
  569.         finally {
  570.             driverConfigurazioneDB.releaseConnection(con);
  571.         }
  572.         
  573.     }
  574.     public static boolean existsRemoteStoreKey(Connection con, String tipoDatabase, long idStore, String kid, boolean checkDates) throws KeystoreException {
  575.         
  576.         PreparedStatement selectStmt = null;
  577.         ResultSet selectRS = null;
  578.         try {
  579.             checkParams(idStore, kid);
  580.             
  581.             Timestamp tooOld = null;
  582.             if(checkDates && RemoteStoreProviderDriver.getKeyMaxLifeMinutes()>0) {
  583.                 long maxLifeSeconds = RemoteStoreProviderDriver.getKeyMaxLifeMinutes() * 60l;
  584.                 long maxLifeMs = maxLifeSeconds * 1000l;
  585.                 tooOld = new Timestamp(DateManager.getTimeMillis()-maxLifeMs);
  586.             }
  587.             
  588.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  589.             sqlQueryObject.addFromTable(CostantiDB.REMOTE_STORE_KEY);
  590.             sqlQueryObject.addSelectField(COLUMN_KEY);
  591.             addWhereKidConditions(sqlQueryObject);
  592.             if(checkDates) {
  593.                 sqlQueryObject.addWhereCondition(COLUMN_DATA_AGGIORNAMENTO+">?");
  594.             }
  595.             sqlQueryObject.setANDLogicOperator(true);
  596.             String sqlQuery = sqlQueryObject.createSQLQuery();
  597.             selectStmt = con.prepareStatement(sqlQuery);
  598.             int index = 1;
  599.             selectStmt.setLong(index++, idStore);
  600.             selectStmt.setString(index++, kid);
  601.             if(checkDates) {
  602.                 if(tooOld!=null) {
  603.                     selectStmt.setTimestamp(index++, tooOld);
  604.                 }
  605.                 else {
  606.                     selectStmt.setTimestamp(index++, dataInvalidaScaduta);
  607.                 }
  608.             }
  609.             selectRS = selectStmt.executeQuery();
  610.             return selectRS.next();
  611.         }
  612.         catch(Exception e) {
  613.             throw new KeystoreException(e.getMessage(),e);
  614.         }
  615.         finally {
  616.             JDBCUtilities.closeResources(selectRS, selectStmt);
  617.         }
  618.         
  619.     }
  620.     
  621.     
  622.     public static RemoteStoreClientDetails getRemoteStoreClientDetails(DriverConfigurazioneDB driverConfigurazioneDB, long idStore, String kid, Logger log,
  623.             boolean createEntryIfNotExists) throws KeystoreException,KeystoreNotFoundException {
  624.         
  625.         Connection con = null;
  626.         try {
  627.             con = driverConfigurazioneDB.getConnection("getRemoteStoreClientDetails");
  628.             
  629.             return getRemoteStoreClientDetails(con, driverConfigurazioneDB.getTipoDB(), idStore, kid, log,
  630.                     createEntryIfNotExists);
  631.         }
  632.         catch(KeystoreNotFoundException e) {
  633.             throw e;
  634.         }
  635.         catch(Exception e) {
  636.             throw new KeystoreException(e.getMessage(),e);
  637.         }
  638.         finally {
  639.             driverConfigurazioneDB.releaseConnection(con);
  640.         }
  641.         
  642.     }
  643.     public static RemoteStoreClientDetails getRemoteStoreClientDetails(Connection con, String tipoDatabase, long idStore, String kid, Logger log, 
  644.             boolean createEntryIfNotExists) throws KeystoreException,KeystoreNotFoundException {
  645.         
  646.         PreparedStatement selectStmt = null;
  647.         ResultSet selectRS = null;
  648.         try {
  649.             checkParams(idStore, kid);
  650.             
  651.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  652.             sqlQueryObject.addFromTable(CostantiDB.REMOTE_STORE_KEY);
  653.             sqlQueryObject.addSelectField(COLUMN_CLIENT_ID);
  654.             sqlQueryObject.addSelectField(COLUMN_CLIENT_DETAILS);
  655.             sqlQueryObject.addSelectField(COLUMN_ORGANIZATION_DETAILS);
  656.             sqlQueryObject.addSelectField(COLUMN_CLIENT_DATA_AGGIORNAMENTO);
  657.             addWhereKidConditions(sqlQueryObject);
  658.             sqlQueryObject.setANDLogicOperator(true);
  659.             String sqlQuery = sqlQueryObject.createSQLQuery();
  660.             selectStmt = con.prepareStatement(sqlQuery);
  661.             selectStmt.setLong(1, idStore);
  662.             selectStmt.setString(2, kid);
  663.             selectRS = selectStmt.executeQuery();
  664.             if(selectRS.next()) {
  665.                 RemoteStoreClientDetails rsk = new RemoteStoreClientDetails();
  666.                 rsk.setClientInfo(new RemoteStoreClientInfo());
  667.                 rsk.getClientInfo().setClientId(selectRS.getString(COLUMN_CLIENT_ID));
  668.                 rsk.getClientInfo().setClientDetails(selectRS.getString(COLUMN_CLIENT_DETAILS));
  669.                 if(rsk.getClientInfo().getClientId()!=null && rsk.getClientInfo().getClientDetails()!=null) {
  670.                     String jsonPath = OpenSPCoop2Properties.getInstance().getGestoreChiaviPDNDclientsOrganizationJsonPath();
  671.                     boolean readErrorAbortTransaction = false;
  672.                     String organizationId = PDNDConfigUtilities.readOrganizationId(jsonPath, readErrorAbortTransaction, rsk.getClientInfo().getClientDetails(), log);
  673.                     rsk.getClientInfo().setOrganizationId(organizationId);
  674.                 }
  675.                 rsk.getClientInfo().setOrganizationDetails(selectRS.getString(COLUMN_ORGANIZATION_DETAILS));
  676.                 rsk.setDataAggiornamento(selectRS.getTimestamp(COLUMN_CLIENT_DATA_AGGIORNAMENTO));
  677.                 rsk.setInvalid(dataInvalidaScaduta.equals(rsk.getDataAggiornamento()));
  678.                 return rsk;
  679.             }
  680.             
  681.             if(createEntryIfNotExists) {
  682.                 int row = initializeEmptyEntry(con, tipoDatabase, idStore, kid, log);
  683.                 if(row>0) {
  684.                     return new RemoteStoreClientDetails();
  685.                 }
  686.             }
  687.             
  688.             throw new KeystoreNotFoundException("Key with kid '"+kid+"'"+SUFFIX_NOT_FOUND);
  689.         }
  690.         catch(KeystoreNotFoundException e) {
  691.             throw e;
  692.         }
  693.         catch(Exception e) {
  694.             throw new KeystoreException(e.getMessage(),e);
  695.         }
  696.         finally {
  697.             JDBCUtilities.closeResources(selectRS, selectStmt);
  698.         }
  699.         
  700.     }
  701.     
  702.     private static final byte[] KEY_UNDEFINED = "KEY_UNDEFINED".getBytes();
  703.     private static int initializeEmptyEntry(Connection con, String tipoDB, long idStore, String kid, Logger log) {
  704.         PreparedStatement updateStmt = null;
  705.         try {
  706.             IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(tipoDB);
  707.             
  708.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  709.             sqlQueryObject.addInsertTable(CostantiDB.REMOTE_STORE_KEY);
  710.             sqlQueryObject.addInsertField(COLUMN_ID_REMOTE_STORE, "?");
  711.             sqlQueryObject.addInsertField(COLUMN_KID, "?");
  712.             sqlQueryObject.addInsertField(COLUMN_KEY, "?");
  713.             sqlQueryObject.addInsertField(COLUMN_DATA_REGISTRAZIONE, "?");
  714.             sqlQueryObject.addInsertField(COLUMN_DATA_AGGIORNAMENTO, "?");
  715.             String updateQuery = sqlQueryObject.createSQLInsert();
  716.             updateStmt = con.prepareStatement(updateQuery);
  717.             int index = 1;
  718.             updateStmt.setLong(index++, idStore);
  719.             updateStmt.setString(index++, kid);
  720.             jdbcAdapter.setBinaryData(updateStmt, index++, KEY_UNDEFINED);
  721.             Timestamp now = DateManager.getTimestamp();
  722.             updateStmt.setTimestamp(index++, now);
  723.             updateStmt.setTimestamp(index++, dataInvalidaScaduta);
  724.             int rows = updateStmt.executeUpdate();
  725.             updateStmt.close();
  726.             return rows;
  727.         }
  728.         catch(Exception e) {
  729.             log.error("initializeEmptyEntry failed: "+e.getMessage(),e);
  730.             return -1;
  731.         }
  732.         finally {
  733.             JDBCUtilities.closeResources(updateStmt);
  734.         }
  735.     }
  736.     
  737.     public static int updateRemoteStoreClientDetails(DriverConfigurazioneDB driverConfigurazioneDB, long idStore, String kid, RemoteStoreClientDetails clientDetails) throws KeystoreException {
  738.         Connection con = null;
  739.         try {
  740.             con = driverConfigurazioneDB.getConnection("updateRemoteStoreClientDetails");
  741.             return updateRemoteStoreClientDetails(con, driverConfigurazioneDB.getTipoDB(), idStore, kid, clientDetails);
  742.         }
  743.         catch(Exception e) {
  744.             throw new KeystoreException(e.getMessage(),e);
  745.         }
  746.         finally {
  747.             driverConfigurazioneDB.releaseConnection(con);
  748.         }
  749.     }
  750.     public static int updateRemoteStoreClientDetails(Connection con, String tipoDatabase, long idStore, String kid, RemoteStoreClientDetails clientDetails) throws KeystoreException {
  751.         PreparedStatement updateStmt = null;
  752.         try {
  753.             checkParams(idStore, kid);  

  755.             if(clientDetails==null) {
  756.                 throw new KeystoreException("ClientDetails undefined");
  757.             }
  758.             if(clientDetails.getClientInfo()==null) {
  759.                 throw new KeystoreException("ClientInfo undefined");
  760.             }
  761.             
  762.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  763.             sqlQueryObject.addUpdateTable(CostantiDB.REMOTE_STORE_KEY);
  764.             sqlQueryObject.addUpdateField(COLUMN_CLIENT_ID, "?");
  765.             sqlQueryObject.addUpdateField(COLUMN_CLIENT_DETAILS, "?");
  766.             sqlQueryObject.addUpdateField(COLUMN_ORGANIZATION_DETAILS, "?");
  767.             sqlQueryObject.addUpdateField(COLUMN_CLIENT_DATA_AGGIORNAMENTO, "?");
  768.             addWhereKidConditions(sqlQueryObject);
  769.             sqlQueryObject.setANDLogicOperator(true);
  770.             String updateQuery = sqlQueryObject.createSQLUpdate();
  771.             updateStmt = con.prepareStatement(updateQuery);
  772.             int index = 1;
  773.             updateStmt.setString(index++, clientDetails.getClientInfo().getClientId());
  774.             updateStmt.setString(index++, clientDetails.getClientInfo().getClientDetails());
  775.             updateStmt.setString(index++, clientDetails.getClientInfo().getOrganizationDetails());
  776.             updateStmt.setTimestamp(index++, clientDetails.getDataAggiornamento()!=null ? new Timestamp(clientDetails.getDataAggiornamento().getTime()) : DateManager.getTimestamp());
  777.             updateStmt.setLong(index++, idStore);
  778.             updateStmt.setString(index++, kid);
  779.             int rows = updateStmt.executeUpdate();
  780.             updateStmt.close();
  781.             return rows;
  782.         }
  783.         catch(Exception e) {
  784.             throw new KeystoreException(e.getMessage(),e);
  785.         }
  786.         finally {
  787.             JDBCUtilities.closeResources(updateStmt);
  788.         }
  789.     }

  791.     
  792.     private static void checkParams(long idStore, String kid, byte[] key) throws KeystoreException {
  793.         checkParams(idStore, kid);
  794.         
  795.         if(key==null || key.length<=0) {
  796.             throw new KeystoreException("Key undefined");
  797.         }
  798.     }
  799.     private static void checkParams(long idStore, String kid) throws KeystoreException {
  800.         if(idStore<=0) {
  801.             throw new KeystoreException("IdStore undefined");
  802.         }
  803.         if(kid==null) {
  804.             throw new KeystoreException("Kid undefined");
  805.         }
  806.     }
  807.     
  808.     private static void addWhereKidConditions(ISQLQueryObject sqlQueryObject) throws SQLQueryObjectException {
  809.         sqlQueryObject.addWhereCondition(COLUMN_ID_REMOTE_STORE+"=?");
  810.         sqlQueryObject.addWhereCondition(COLUMN_KID+"=?");
  811.     }
  812.     
  813.     
  814.     
  815.     
  816.     
  817.     
  818.     
  819.     
  820.     
  821.     
  822.     
  823.     
  824.     public static List<RemoteStoreKeyEntry> getRemoteStoreKeyEntries(Logger log, DriverConfigurazioneDB driverConfigurazioneDB, ISearch ricerca, long idRemoteStore) throws KeystoreException {
  825.         Connection con = null;
  826.         try {
  827.             con = driverConfigurazioneDB.getConnection("getRemoteStoreKeyEntries");
  828.             return getRemoteStoreKeyEntries(log, con, driverConfigurazioneDB.getTipoDB(), ricerca, idRemoteStore);
  829.         }
  830.         catch(Exception e) {
  831.             throw new KeystoreException(e.getMessage(),e);
  832.         }
  833.         finally {
  834.             driverConfigurazioneDB.releaseConnection(con);
  835.         }
  836.     }
  837.     public static List<RemoteStoreKeyEntry> getRemoteStoreKeyEntries(Logger log, Connection con, String tipoDatabase, ISearch ricerca, long idRemoteStore) throws KeystoreException {
  838.         
  839.         int idLista = Liste.REMOTE_STORE_KEY;
  840.         int offset;
  841.         int limit;
  842.         limit = ricerca.getPageSize(idLista);
  843.         offset = ricerca.getIndexIniziale(idLista);
  844.         
  845.         if (limit == 0) // con limit
  846.             limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  847.         
  848.         String filtroKid = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_REMOTE_STORE_KEY_KID);
  849.         if((filtroKid!=null && "".equals(filtroKid))) {
  850.             filtroKid=null;
  851.         }
  852.         
  853.         String filtroClientId = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_REMOTE_STORE_KEY_CLIENT_ID);
  854.         if((filtroClientId!=null && "".equals(filtroClientId))) {
  855.             filtroClientId=null;
  856.         }
  857.         
  858.         String filtroOrganizzazione = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_REMOTE_STORE_KEY_ORGANIZZAZIONE);
  859.         if((filtroOrganizzazione!=null && "".equals(filtroOrganizzazione))) {
  860.             filtroOrganizzazione=null;
  861.         }

  863.         // count
  864.         PreparedStatement selectStmtCount = null;
  865.         ResultSet selectRSCount = null;
  866.         int size = 0;
  867.         try {
  868.             ISQLQueryObject sqlQueryObject = buildSqlRemoteStoreKeyEntries(tipoDatabase, filtroKid, filtroClientId, filtroOrganizzazione);
  869.             sqlQueryObject.addSelectCountField("somma");
  870.             String sqlQuery = sqlQueryObject.createSQLQuery();
  871.             selectStmtCount = con.prepareStatement(sqlQuery);
  872.             selectStmtCount.setLong(1, idRemoteStore);
  873.             selectRSCount = selectStmtCount.executeQuery();
  874.             if(selectRSCount.next()) {
  875.                 size = selectRSCount.getInt("somma");
  876.                 if(size<0) {
  877.                     size=0;
  878.                 }
  879.                 ricerca.setNumEntries(idLista, size);
  880.             }
  881.         }
  882.         catch(Exception e) {
  883.             throw new KeystoreException(e.getMessage(),e);
  884.         }
  885.         finally {
  886.             JDBCUtilities.closeResources(selectRSCount, selectStmtCount);
  887.         }
  888.         
  889.         List<RemoteStoreKeyEntry> list = new ArrayList<>();
  890.         PreparedStatement selectStmt = null;
  891.         ResultSet selectRS = null;
  892.         try {
  893.             IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(tipoDatabase);
  894.             
  895.             ISQLQueryObject sqlQueryObject = buildSqlRemoteStoreKeyEntries(tipoDatabase, filtroKid, filtroClientId, filtroOrganizzazione);
  896.             sqlQueryObject.addOrderBy(COLUMN_DATA_REGISTRAZIONE, false);
  897.             sqlQueryObject.setOffset(offset);
  898.             sqlQueryObject.setLimit(limit);
  899.             String sqlQuery = sqlQueryObject.createSQLQuery();
  900.             selectStmt = con.prepareStatement(sqlQuery);
  901.             selectStmt.setLong(1, idRemoteStore);
  902.             selectRS = selectStmt.executeQuery();
  903.             while(selectRS.next()) {
  904.                 list.add(readKeyEntry(log, selectRS, jdbcAdapter));
  905.             }
  906.         }
  907.         catch(Exception e) {
  908.             throw new KeystoreException(e.getMessage(),e);
  909.         }
  910.         finally {
  911.             
  912.             JDBCUtilities.closeResources(selectRS, selectStmt);
  913.         }
  914.         
  915.         return list;
  916.     }
  917.     
  918.     private static ISQLQueryObject buildSqlRemoteStoreKeyEntries(String tipoDatabase, String filtroKid, String filtroClientId, String filtroOrganizzazione) throws KeystoreException {
  919.         ISQLQueryObject sqlQueryObject = null;
  920.         try {
  921.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  922.             sqlQueryObject.addFromTable(CostantiDB.REMOTE_STORE_KEY);
  923.             sqlQueryObject.addWhereCondition(COLUMN_ID_REMOTE_STORE+"=?");
  924.             if(filtroKid!=null) {
  925.                 if(filtroKid.equals("-")) {
  926.                     sqlQueryObject.addWhereLikeCondition(COLUMN_KID, PDNDResolver.REMOTE_STORE_KEY_KID_STARTS_WITH_CLIENT_ID, LikeConfig.startsWith(false));
  927.                 }
  928.                 else {
  929.                     sqlQueryObject.addWhereLikeCondition(COLUMN_KID, filtroKid, LikeConfig.contains(true));
  930.                 }
  931.             }
  932.             if(filtroClientId!=null) {
  933.                 if(filtroClientId.equals("-")) {
  934.                     sqlQueryObject.addWhereIsNullCondition(COLUMN_CLIENT_ID);
  935.                 }
  936.                 else {
  937.                     sqlQueryObject.addWhereLikeCondition(COLUMN_CLIENT_ID, filtroClientId, LikeConfig.contains(true));
  938.                 }
  939.             }
  940.             if(filtroOrganizzazione!=null) {
  941.                 if(filtroOrganizzazione.equals("-")) {
  942.                     sqlQueryObject.addWhereIsNullCondition(COLUMN_ORGANIZATION_DETAILS);
  943.                 }
  944.                 else {
  945.                     sqlQueryObject.addWhereLikeCondition(COLUMN_ORGANIZATION_DETAILS, filtroOrganizzazione, LikeConfig.contains(true));
  946.                 }
  947.             }
  948.             sqlQueryObject.setANDLogicOperator(true);
  949.         }
  950.         catch(Exception e) {
  951.             throw new KeystoreException(e.getMessage(),e);
  952.         }
  953.         return sqlQueryObject;
  954.     }
  955.     
  956.     private static RemoteStoreKeyEntry readKeyEntry(Logger log, ResultSet selectRS, IJDBCAdapter jdbcAdapter) throws SQLException, UtilsException {
  957.         long id = selectRS.getLong(COLUMN_ID);
  958.         long idStore = selectRS.getLong(COLUMN_ID_REMOTE_STORE);
  959.         Date dataRegistrazione = selectRS.getTimestamp(COLUMN_DATA_REGISTRAZIONE);
  960.         
  961.         String kid = selectRS.getString(COLUMN_KID);
  962.         Date dataAggiornamento = selectRS.getTimestamp(COLUMN_DATA_AGGIORNAMENTO);
  963.         
  964.         String clientId =  selectRS.getString(COLUMN_CLIENT_ID);
  965.         String clientDetails = selectRS.getString(COLUMN_CLIENT_DETAILS);
  966.         String organizationDetails = selectRS.getString(COLUMN_ORGANIZATION_DETAILS);
  967.         Date clientDataAggiornamento = selectRS.getTimestamp(COLUMN_CLIENT_DATA_AGGIORNAMENTO);
  968.         
  969.         RemoteStoreKeyEntry rs = new RemoteStoreKeyEntry();
  970.         rs.setId(id);
  971.         rs.setDataRegistrazione(dataRegistrazione);
  972.         rs.setIdRemoteStore(idStore);
  973.         
  974.         rs.setContentKey(jdbcAdapter.getBinaryData(selectRS, COLUMN_KEY));
  975.         rs.setKid(kid);
  976.         rs.setDataAggiornamento(dataAggiornamento);
  977.         
  978.         rs.setClientId(clientId);
  979.         rs.setClientDetails(clientDetails);
  980.         rs.setOrganizationDetails(organizationDetails);
  981.         rs.setClientDataAggiornamento(clientDataAggiornamento);
  982.         
  983.         enrichOrganizationInfo(log, organizationDetails, rs);
  984.         return rs;
  985.     }
  986.     
  987.     private static void enrichOrganizationInfo(Logger log, String organizationDetails, RemoteStoreKeyEntry rs) {
  988.         if(organizationDetails!=null) {
  989.             try {
  990.                 rs.setOrganizationName(JsonPathExpressionEngine.extractAndConvertResultAsString(organizationDetails, "$.name", log));
  991.             }catch(Exception e) {
  992.                 // ignore
  993.             }
  994.             try {
  995.                 rs.setOrganizationExternalOrigin(JsonPathExpressionEngine.extractAndConvertResultAsString(organizationDetails, "$.externalId.origin", log));
  996.             }catch(Exception e) {
  997.                 // ignore
  998.             }
  999.             try {
  1000.                 rs.setOrganizationExternalId(JsonPathExpressionEngine.extractAndConvertResultAsString(organizationDetails, "$.externalId.id", log));
  1001.             }catch(Exception e) {
  1002.                 // ignore
  1003.             }
  1004.             try {
  1005.                 rs.setOrganizationCategory(JsonPathExpressionEngine.extractAndConvertResultAsString(organizationDetails, "$.category", log));
  1006.             }catch(Exception e) {
  1007.                 // ignore
  1008.             }
  1009.         }
  1010.     }
  1011.     
  1012.     
  1013.     public static int deleteRemoteStoreKeyEntry(DriverConfigurazioneDB driverConfigurazioneDB, long idRemoteStore, long idEntry) throws KeystoreException {
  1014.         Connection con = null;
  1015.         try {
  1016.             con = driverConfigurazioneDB.getConnection("deleteRemoteStoreKeyEntry");
  1017.             return deleteRemoteStoreKeyEntry(con, driverConfigurazioneDB.getTipoDB(), idRemoteStore, idEntry);
  1018.         }
  1019.         catch(Exception e) {
  1020.             throw new KeystoreException(e.getMessage(),e);
  1021.         }
  1022.         finally {
  1023.             driverConfigurazioneDB.releaseConnection(con);
  1024.         }
  1025.     }
  1026.     public static int deleteRemoteStoreKeyEntry(Connection con, String tipoDatabase, long idRemoteStore, long idEntry) throws KeystoreException {
  1027.         PreparedStatement updateStmt = null;
  1028.         try {
  1029.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  1030.             sqlQueryObject.addDeleteTable(CostantiDB.REMOTE_STORE_KEY);
  1031.             sqlQueryObject.addWhereCondition(COLUMN_ID_REMOTE_STORE+"=?");
  1032.             sqlQueryObject.addWhereCondition(COLUMN_ID+"=?");
  1033.             sqlQueryObject.setANDLogicOperator(true);
  1034.             String updateQuery = sqlQueryObject.createSQLDelete();
  1035.             updateStmt = con.prepareStatement(updateQuery);
  1036.             updateStmt.setLong(1, idRemoteStore);
  1037.             updateStmt.setLong(2, idEntry);
  1038.             int rows = updateStmt.executeUpdate();
  1039.             updateStmt.close();
  1040.             return rows;
  1041.         }
  1042.         catch(Exception e) {
  1043.             throw new KeystoreException(e.getMessage(),e);
  1044.         }
  1045.         finally {
  1046.             JDBCUtilities.closeResources(updateStmt);
  1047.         }
  1048.     }
  1049.     
  1050.     public static RemoteStoreKeyEntry getRemoteStoreKeyEntry(Logger log, DriverConfigurazioneDB driverConfigurazioneDB, long idRemoteStoreKey) throws KeystoreException, KeystoreNotFoundException {
  1051.         Connection con = null;
  1052.         try {
  1053.             con = driverConfigurazioneDB.getConnection("getRemoteStoreKeyEntry");
  1054.             return getRemoteStoreKeyEntry(log, con, driverConfigurazioneDB.getTipoDB(), idRemoteStoreKey);
  1055.         }
  1056.         catch(Exception e) {
  1057.             throw new KeystoreException(e.getMessage(),e);
  1058.         }
  1059.         finally {
  1060.             driverConfigurazioneDB.releaseConnection(con);
  1061.         }
  1062.     }
  1063.     
  1064.     public static RemoteStoreKeyEntry getRemoteStoreKeyEntry(Logger log, Connection con, String tipoDatabase, long idRemoteStoreKey) throws KeystoreException,KeystoreNotFoundException {
  1065.         
  1066.         PreparedStatement selectStmt = null;
  1067.         ResultSet selectRS = null;
  1068.         try {
  1069.             IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(tipoDatabase);
  1070.             
  1071.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  1072.             sqlQueryObject.addFromTable(CostantiDB.REMOTE_STORE_KEY);
  1073.             sqlQueryObject.addWhereCondition(COLUMN_ID+"=?");
  1074.             sqlQueryObject.setANDLogicOperator(true);
  1075.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1076.             selectStmt = con.prepareStatement(sqlQuery);
  1077.             selectStmt.setLong(1, idRemoteStoreKey);
  1078.             selectRS = selectStmt.executeQuery();
  1079.             if(selectRS.next()) {
  1080.                 return readKeyEntry(log, selectRS, jdbcAdapter);
  1081.             }
  1082.             throw new KeystoreNotFoundException("Key with id '"+idRemoteStoreKey+"'"+SUFFIX_NOT_FOUND);
  1083.         }
  1084.         catch(KeystoreNotFoundException e) {
  1085.             throw e;
  1086.         }
  1087.         catch(Exception e) {
  1088.             throw new KeystoreException(e.getMessage(),e);
  1089.         }
  1090.         finally {
  1091.             JDBCUtilities.closeResources(selectRS, selectStmt);
  1092.         }
  1093.     }
  1094. }
Created with JaCoCo 0.8.8.202204050719