ArchiviCore.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.web.ctrlstat.servlet.archivi;

  23. import java.io.ByteArrayOutputStream;
  24. import java.io.OutputStream;
  25. import java.sql.Connection;
  26. import java.util.List;

  28. import org.openspcoop2.core.registry.Documento;
  29. import org.openspcoop2.core.registry.constants.ProprietariDocumento;
  30. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  31. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  32. import org.openspcoop2.protocol.basic.registry.ConfigIntegrationReader;
  33. import org.openspcoop2.protocol.basic.registry.RegistryReader;
  34. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  35. import org.openspcoop2.protocol.engine.archive.ArchiveValidator;
  36. import org.openspcoop2.protocol.engine.archive.DeleterArchiveUtils;
  37. import org.openspcoop2.protocol.engine.archive.ExporterArchiveUtils;
  38. import org.openspcoop2.protocol.engine.archive.ImportInformationMissingCollection;
  39. import org.openspcoop2.protocol.engine.archive.ImportInformationMissingException;
  40. import org.openspcoop2.protocol.engine.archive.ImporterArchiveUtils;
  41. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  42. import org.openspcoop2.protocol.sdk.archive.Archive;
  43. import org.openspcoop2.protocol.sdk.archive.ArchiveCascadeConfiguration;
  44. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoDelete;
  45. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImport;
  46. import org.openspcoop2.protocol.sdk.archive.ArchiveMode;
  47. import org.openspcoop2.protocol.sdk.archive.ArchiveModeType;
  48. import org.openspcoop2.protocol.sdk.archive.ExportMode;
  49. import org.openspcoop2.protocol.sdk.archive.IArchive;
  50. import org.openspcoop2.protocol.sdk.archive.MapPlaceholder;
  51. import org.openspcoop2.protocol.sdk.constants.ArchiveType;
  52. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  53. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationDB;
  54. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  55. import org.openspcoop2.web.ctrlstat.servlet.ConsoleHelper;

  57. /**
  58.  * ArchiviCore
  59.  * 
  60.  * @author Andrea Poli (apoli@link.it)
  61.  * @author $Author$
  62.  * @version $Rev$, $Date$
  63.  */
  64. public class ArchiviCore extends ControlStationCore {

  66.     public ArchiviCore() throws Exception {
  67.         super();
  68.     }
  69.     public ArchiviCore(ControlStationCore core) throws Exception {
  70.         super(core);
  71.     }

  73.     public boolean isCascadeEnabled(List<ExportMode> exportModes,String exportMode){
  74.         boolean cascadeEnabled = false;
  75.         for (ExportMode exp : exportModes) {
  76.             if(exp.equals(exportMode) &&
  77.                 exp.getCascade()!=null &&
  78.                         (exp.getCascade().isCascadePdd() || 
  79.                                 exp.getCascade().isCascadeRuoli() || 
  80.                                 exp.getCascade().isCascadeScope() || 
  81.                                 exp.getCascade().isCascadeSoggetti() ||
  82.                                 exp.getCascade().isCascadeServiziApplicativi() || 
  83.                                 exp.getCascade().isCascadePorteDelegate() ||
  84.                                 exp.getCascade().isCascadePorteApplicative() ||
  85.                                 exp.getCascade().isCascadeAccordoCooperazione() ||
  86.                                 exp.getCascade().isCascadeAccordoServizioComposto() ||
  87.                                 exp.getCascade().isCascadeAccordoServizioParteComune() ||
  88.                                 exp.getCascade().isCascadeAccordoServizioParteSpecifica() ||
  89.                                 exp.getCascade().isCascadeFruizioni()
  90.                         ) 
  91.             ){
  92.                 cascadeEnabled = true;
  93.                 break;
  94.             }
  95.         }
  96.         return cascadeEnabled;
  97.     }
  98.     public ArchiveCascadeConfiguration getCascadeConfig(List<ExportMode> exportModes,String exportMode){
  99.         for (ExportMode exp : exportModes) {
  100.             if(exp.equals(exportMode)){
  101.                 return exp.getCascade();
  102.             }
  103.         }
  104.         return null;
  105.     }
  106.     
  107.     public byte[] export(String userLogin, boolean smista,
  108.             String protocol,Archive archive,ArchiveMode archiveMode) throws DriverControlStationException, ImportInformationMissingException{
  109.         
  110.         Connection con = null;
  111.         DriverControlStationDB driver = null;

  113.         ByteArrayOutputStream bout = null;
  114.         try {
  115.             // prendo una connessione
  116.             con = ControlStationCore.dbM.getConnection();
  117.             // istanzio il driver
  118.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  120.             ArchiveEngine importerEngine = new ArchiveEngine(driver.getDriverRegistroServiziDB(), 
  121.                     driver.getDriverConfigurazioneDB(), 
  122.                     driver.getJdbcServiceManagerPlugins(),
  123.                     driver.getJdbcServiceManagerControlloTraffico(),
  124.                     driver.getJdbcServiceManagerAllarmi(),
  125.                     this, smista, userLogin);
  126.             
  127.             ExporterArchiveUtils exportUtils = new ExporterArchiveUtils(importerEngine, log);
  128.             
  129.             bout = new ByteArrayOutputStream();
  130.             exportUtils.export(protocol, archive, bout, archiveMode);
  131.             
  132.             bout.flush();
  133.             bout.close();
  134.             return bout.toByteArray();
  135.             
  136.         } 
  137.         catch(ImportInformationMissingException iime) {
  138.             throw iime;
  139.         }
  140.         catch(Exception e) {
  141.             throw new DriverControlStationException(getPrefixError("export",  e),e);
  142.         }
  143.         finally {
  144.             ControlStationCore.dbM.releaseConnection(con);
  145.         }
  146.     }
  147.     
  148.     public void export(String userLogin, boolean smista,
  149.             String protocol,Archive archive,OutputStream out, ArchiveMode archiveMode) throws DriverControlStationException, ImportInformationMissingException{
  150.         
  151.         Connection con = null;
  152.         DriverControlStationDB driver = null;

  154.         try {
  155.             // prendo una connessione
  156.             con = ControlStationCore.dbM.getConnection();
  157.             // istanzio il driver
  158.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  160.             ArchiveEngine importerEngine = new ArchiveEngine(driver.getDriverRegistroServiziDB(), 
  161.                     driver.getDriverConfigurazioneDB(), 
  162.                     driver.getJdbcServiceManagerPlugins(),
  163.                     driver.getJdbcServiceManagerControlloTraffico(),
  164.                     driver.getJdbcServiceManagerAllarmi(),
  165.                     this, smista, userLogin);
  166.             
  167.             ExporterArchiveUtils exportUtils = new ExporterArchiveUtils(importerEngine, log);
  168.             
  169.             exportUtils.export(protocol, archive, out, archiveMode);
  170.             
  171.         } 
  172.         catch(ImportInformationMissingException iime) {
  173.             throw iime;
  174.         }
  175.         catch(Exception e) {
  176.             throw new DriverControlStationException(getPrefixError("export",  e),e);
  177.         }
  178.         finally {
  179.             ControlStationCore.dbM.releaseConnection(con);
  180.         }
  181.     }
  182.     
  183.     public Archive readArchiveForExport(String userLogin, boolean smista,ArchiveType tipoEsportazione,List<?> listObject, ArchiveCascadeConfiguration cascadeConfig) throws DriverControlStationException, ImportInformationMissingException{
  184.         
  185.         Connection con = null;
  186.         DriverControlStationDB driver = null;

  188.         try {
  189.             // prendo una connessione
  190.             con = ControlStationCore.dbM.getConnection();
  191.             // istanzio il driver
  192.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  194.             ArchiveEngine importerEngine = new ArchiveEngine(driver.getDriverRegistroServiziDB(), 
  195.                     driver.getDriverConfigurazioneDB(),
  196.                     driver.getJdbcServiceManagerPlugins(),
  197.                     driver.getJdbcServiceManagerControlloTraffico(),
  198.                     driver.getJdbcServiceManagerAllarmi(),
  199.                     this, smista, userLogin);
  200.             
  201.             ExporterArchiveUtils exportUtils = new ExporterArchiveUtils(importerEngine, log);
  202.             Archive archive = new Archive();
  203.             exportUtils.fillArchive(archive, tipoEsportazione, listObject, cascadeConfig);
  204.             
  205.             return archive;
  206.             
  207.         } 
  208.         catch(ImportInformationMissingException iime) {
  209.             throw iime;
  210.         }
  211.         catch(Exception e) {
  212.             throw new DriverControlStationException(getPrefixError("readArchiveForExport",  e),e);
  213.         }
  214.         finally {
  215.             ControlStationCore.dbM.releaseConnection(con);
  216.         }
  217.     }
  218.     
  219.     public String importArchive(Archive archive,ArchiveMode archiveMode,String protocol, String userLogin, boolean smista,
  220.             boolean updateAbilitato, 
  221.             boolean importPolicyConfig, 
  222.             boolean importPluginConfig, boolean checkExistsPluginConfig,
  223.             boolean importConfig, String nomePddOperativa,
  224.             ConsoleHelper consoleHelper) throws DriverControlStationException, ImportInformationMissingException{
  225.         
  226.         Connection con = null;
  227.         DriverControlStationDB driver = null;

  229.         try {
  230.             // prendo una connessione
  231.             con = ControlStationCore.dbM.getConnection();
  232.             // istanzio il driver
  233.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  235.             ArchiveEngine importerEngine = new ArchiveEngine(driver.getDriverRegistroServiziDB(), 
  236.                     driver.getDriverConfigurazioneDB(),
  237.                     driver.getJdbcServiceManagerPlugins(),
  238.                     driver.getJdbcServiceManagerControlloTraffico(),
  239.                     driver.getJdbcServiceManagerAllarmi(),
  240.                     this, smista, userLogin);
  241.             
  242.             ImporterArchiveUtils importerArchiveUtils = 
  243.                     new ImporterArchiveUtils(importerEngine, log, userLogin, nomePddOperativa, this.getImportArchivi_tipoPdD(), 
  244.                             consoleHelper.isShowGestioneWorkflowStatoDocumenti(), updateAbilitato,
  245.                             importPolicyConfig, 
  246.                             importPluginConfig, checkExistsPluginConfig,
  247.                             importConfig);
  248.             
  249.             ArchiveEsitoImport esito = importerArchiveUtils.importArchive(archive, userLogin, 
  250.                     this.isShowAccordiColonnaAzioni(),
  251.                     this.isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto(), 
  252.                     this.isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto(),
  253.                     this.isSoggettiApplicativiCredenzialiBasicPermitSameCredentials(),
  254.                     this.isSoggettiApplicativiCredenzialiSslPermitSameCredentials(),
  255.                     this.isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials());
  256.             
  257.             IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocol);
  258.             IArchive archiveEngine = pf.createArchive();
  259.             return archiveEngine.toString(esito, archiveMode);
  260.                         
  261.         } 
  262.         catch(ImportInformationMissingException iime) {
  263.             throw iime;
  264.         }
  265.         catch(Exception e) {
  266.             throw new DriverControlStationException(getPrefixError("importArchive",  e),e);
  267.         }
  268.         finally {
  269.             ControlStationCore.dbM.releaseConnection(con);
  270.         }
  271.     }
  272.     
  273.     
  274.     public String deleteArchive(Archive archive,ArchiveMode archiveMode,String protocol, String userLogin, boolean smista,
  275.              boolean deletePolicyConfig, boolean deletePluginConfig) throws DriverControlStationException, ImportInformationMissingException{
  276.         
  277.         Connection con = null;
  278.         DriverControlStationDB driver = null;

  280.         try {
  281.             // prendo una connessione
  282.             con = ControlStationCore.dbM.getConnection();
  283.             // istanzio il driver
  284.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  286.             ArchiveEngine importerEngine = new ArchiveEngine(driver.getDriverRegistroServiziDB(), 
  287.                     driver.getDriverConfigurazioneDB(),
  288.                     driver.getJdbcServiceManagerPlugins(),
  289.                     driver.getJdbcServiceManagerControlloTraffico(),
  290.                     driver.getJdbcServiceManagerAllarmi(),
  291.                     this, smista, userLogin);
  292.             
  293.             DeleterArchiveUtils deleterArchiveUtils = 
  294.                     new DeleterArchiveUtils(importerEngine, log, userLogin,
  295.                             deletePolicyConfig, deletePluginConfig);
  296.             
  297.             ArchiveEsitoDelete esito = deleterArchiveUtils.deleteArchive(archive, userLogin);
  298.             
  299.             IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocol);
  300.             IArchive archiveEngine = pf.createArchive();
  301.             return archiveEngine.toString(esito, archiveMode);
  302.                         
  303.         } 
  304.         catch(ImportInformationMissingException iime) {
  305.             throw iime;
  306.         }
  307.         catch(Exception e) {
  308.             throw new DriverControlStationException(getPrefixError("deleteArchive",  e),e);
  309.         }
  310.         finally {
  311.             ControlStationCore.dbM.releaseConnection(con);
  312.         }
  313.     }
  314.             
  315.     
  316.     public void validateArchive(Archive archive, String protocolloEffettivo, 
  317.             boolean validazioneDocumenti, ImportInformationMissingCollection importInformationMissingCollection, 
  318.             String userLogin, boolean delete) throws ImportInformationMissingException, DriverControlStationException{
  319.         
  320.         Connection con = null;
  321.         DriverControlStationDB driver = null;

  323.         try {
  324.             // prendo una connessione
  325.             con = ControlStationCore.dbM.getConnection();
  326.             // istanzio il driver
  327.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  329.             RegistryReader reader = new RegistryReader(driver.getDriverRegistroServiziDB(),ControlStationCore.getLog());
  330.             
  331.             ArchiveValidator validator = new ArchiveValidator(reader);
  332.             validator.validateArchive(archive, protocolloEffettivo, validazioneDocumenti, importInformationMissingCollection, userLogin, 
  333.                     this.isShowCorrelazioneAsincronaInAccordi(),delete);
  334.             
  335.         } 
  336.         catch(ImportInformationMissingException iime) {
  337.             throw iime;
  338.         }
  339.         catch(Exception e) {
  340.             throw new DriverControlStationException(getPrefixError("validateArchive",  e),e);
  341.         }
  342.         finally {
  343.             ControlStationCore.dbM.releaseConnection(con);
  344.         }
  345.     }
  346.     
  347.     
  348.     public Archive convert(byte[] file,ArchiveModeType type,ArchiveMode mode,String protocol,boolean validateDocuments,
  349.             MapPlaceholder importInformationMissingGlobalPlaceholder) throws DriverControlStationException, ImportInformationMissingException {
  350.         Connection con = null;
  351.         DriverControlStationDB driver = null;

  353.         try {
  354.             // prendo una connessione
  355.             con = ControlStationCore.dbM.getConnection();
  356.             // istanzio il driver
  357.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  359.             RegistryReader registryReader = new RegistryReader(driver.getDriverRegistroServiziDB(),ControlStationCore.getLog());
  360.             ConfigIntegrationReader configReader = new ConfigIntegrationReader(driver.getDriverConfigurazioneDB(),ControlStationCore.getLog());
  361.             
  362.             IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocol);
  363.             IArchive archiveEngine = pf.createArchive();
  364.             return archiveEngine.importArchive(file, mode, type, registryReader, configReader,
  365.                     validateDocuments, importInformationMissingGlobalPlaceholder);
  366.             
  367.         } 
  368.         catch(Exception e) {
  369.             throw new DriverControlStationException(getPrefixError("convert",  e),e);
  370.         }
  371.         finally {
  372.             ControlStationCore.dbM.releaseConnection(con);
  373.         }
  374.     }
  375.     
  376.     public void finalizeArchive(Archive archive,ArchiveModeType type,ArchiveMode mode,String protocol,boolean validateDocuments,
  377.             MapPlaceholder importInformationMissingGlobalPlaceholder) throws DriverControlStationException, ImportInformationMissingException {
  378.         Connection con = null;
  379.         DriverControlStationDB driver = null;

  381.         try {
  382.             // prendo una connessione
  383.             con = ControlStationCore.dbM.getConnection();
  384.             // istanzio il driver
  385.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  387.             RegistryReader registryReader = new RegistryReader(driver.getDriverRegistroServiziDB(),ControlStationCore.getLog());
  388.             ConfigIntegrationReader configReader = new ConfigIntegrationReader(driver.getDriverConfigurazioneDB(),ControlStationCore.getLog());
  389.             
  390.             IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocol);
  391.             IArchive archiveEngine = pf.createArchive();
  392.             archiveEngine.finalizeImportArchive(archive, mode, type, registryReader, configReader,
  393.                     validateDocuments, importInformationMissingGlobalPlaceholder);
  394.             
  395.         } 
  396.         catch(Exception e) {
  397.             throw new DriverControlStationException(getPrefixError("finalizeArchive",  e),e);
  398.         }
  399.         finally {
  400.             ControlStationCore.dbM.releaseConnection(con);
  401.         }
  402.     }
  403.     
  404.     
  405.     public Documento getDocumento(long idDocumento,boolean readBytes) throws DriverRegistroServiziException {
  406.         Connection con = null;
  407.         String nomeMetodo = "getDocumento";
  408.         DriverControlStationDB driver = null;

  410.         try {
  411.             // prendo una connessione
  412.             con = ControlStationCore.dbM.getConnection();
  413.             // istanzio il driver
  414.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  416.             return driver.getDriverRegistroServiziDB().getDocumento(idDocumento,readBytes);
  417.             
  418.         } catch (DriverRegistroServiziException e) {
  419.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  420.             throw e;
  421.         } catch (Exception e) {
  422.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  423.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  424.         } finally {
  425.             ControlStationCore.dbM.releaseConnection(con);
  426.         }
  427.     }
  428.     
  429.     public Documento getDocumento(String nome, String tipo, String ruolo, long idProprietario,boolean readBytes,ProprietariDocumento tipoProprietario) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  430.         Connection con = null;
  431.         String nomeMetodo = "getDocumento";
  432.         DriverControlStationDB driver = null;

  434.         try {
  435.             // prendo una connessione
  436.             con = ControlStationCore.dbM.getConnection();
  437.             // istanzio il driver
  438.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  440.             return driver.getDriverRegistroServiziDB().getDocumento(nome,tipo,ruolo,idProprietario,readBytes,tipoProprietario);
  441.             
  442.         } catch (DriverRegistroServiziNotFound e) {
  443.             // Lasciare DEBUG, usato anche in servizio API RS
  444.             ControlStationCore.logDebug("[ControlStationCore::" + nomeMetodo + "] NotFound :" + e.getMessage(), e);
  445.             throw e;
  446.         } catch (DriverRegistroServiziException e) {
  447.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  448.             throw e;
  449.         } catch (Exception e) {
  450.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  451.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  452.         } finally {
  453.             ControlStationCore.dbM.releaseConnection(con);
  454.         }
  455.     }

  457.     public boolean existsDocumento(Documento documento,ProprietariDocumento proprietarioDocumento, boolean documentoUnivocoIndipendentementeTipo) throws DriverRegistroServiziException {
  458.         Connection con = null;
  459.         String nomeMetodo = "existsDocumento";
  460.         DriverControlStationDB driver = null;

  462.         try {
  463.             // prendo una connessione
  464.             con = ControlStationCore.dbM.getConnection();
  465.             // istanzio il driver
  466.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  467.             
  468.             String tipo = documento.getTipo();
  469.             String ruoloDoc = documento.getRuolo();
  470.             if(documentoUnivocoIndipendentementeTipo) {
  471.                 tipo = null;
  472.                 ruoloDoc = null;
  473.             }
  474.             
  475.             return driver.getDriverRegistroServiziDB().existsDocumento(documento.getFile(),tipo,ruoloDoc,documento.getIdProprietarioDocumento(),proprietarioDocumento);
  476.         } catch (Exception e) {
  477.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  478.             throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e),e);
  479.         } finally {
  480.             ControlStationCore.dbM.releaseConnection(con);
  481.         }
  482.     }
  483. }
Created with JaCoCo 0.8.8.202204050719