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.utils.TipiDatabase;
  41. import org.openspcoop2.utils.UtilsException;
  42. import org.openspcoop2.utils.certificate.remote.RemoteStoreClientInfo;
  43. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  44. import org.openspcoop2.utils.date.DateManager;
  45. import org.openspcoop2.utils.date.DateUtils;
  46. import org.openspcoop2.utils.jdbc.CustomKeyGeneratorObject;
  47. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  48. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKey;
  49. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKeyJDBCType;
  50. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKeyObject;
  51. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  52. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  53. import org.openspcoop2.utils.json.JsonPathExpressionEngine;
  54. import org.openspcoop2.utils.sql.ISQLQueryObject;
  55. import org.openspcoop2.utils.sql.LikeConfig;
  56. import org.openspcoop2.utils.sql.SQLObjectFactory;
  57. import org.openspcoop2.utils.sql.SQLQueryObjectException;
  58. import org.slf4j.Logger;

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

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

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

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

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