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


  22. package org.openspcoop2.web.ctrlstat.servlet.archivi;

  24. import java.util.ArrayList;
  25. import java.util.HashMap;
  26. import java.util.List;
  27. import java.util.Map;

  29. import javax.servlet.http.HttpServletRequest;
  30. import javax.servlet.http.HttpServletResponse;
  31. import javax.servlet.http.HttpSession;

  33. import org.apache.commons.lang.StringEscapeUtils;
  34. import org.apache.struts.action.Action;
  35. import org.apache.struts.action.ActionForm;
  36. import org.apache.struts.action.ActionForward;
  37. import org.apache.struts.action.ActionMapping;
  38. import org.apache.struts.upload.FormFile;
  39. import org.openspcoop2.protocol.engine.archive.ImportInformationMissingCollection;
  40. import org.openspcoop2.protocol.engine.archive.ImportInformationMissingException;
  41. import org.openspcoop2.protocol.information_missing.Wizard;
  42. import org.openspcoop2.protocol.sdk.archive.Archive;
  43. import org.openspcoop2.protocol.sdk.archive.ArchiveModeType;
  44. import org.openspcoop2.protocol.sdk.archive.ImportMode;
  45. import org.openspcoop2.protocol.sdk.archive.MapPlaceholder;
  46. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  47. import org.openspcoop2.web.ctrlstat.core.ControlStationCoreException;
  48. import org.openspcoop2.web.ctrlstat.servlet.GeneralHelper;
  49. import org.openspcoop2.web.ctrlstat.servlet.pdd.PddCore;
  50. import org.openspcoop2.web.lib.mvc.DataElement;
  51. import org.openspcoop2.web.lib.mvc.DataElementType;
  52. import org.openspcoop2.web.lib.mvc.GeneralData;
  53. import org.openspcoop2.web.lib.mvc.PageData;
  54. import org.openspcoop2.web.lib.mvc.Parameter;
  55. import org.openspcoop2.web.lib.mvc.ServletUtils;

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

  66.     @Override
  67.     public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

  69.         HttpSession session = request.getSession(true);

  71.         // Inizializzo PageData
  72.         PageData pd = new PageData();

  74.         GeneralHelper generalHelper = new GeneralHelper(session);

  76.         // Inizializzo GeneralData
  77.         GeneralData gd = generalHelper.initGeneralData(request);

  79.         try {
  80.             
  81.             String userLogin = ServletUtils.getUserLoginFromSession(session);
  82.             
  83.             ArchiviHelper archiviHelper = new ArchiviHelper(request, pd, session);
  84.             ArchiviCore archiviCore = new ArchiviCore();
  85.             
  86.             PddCore pddCore = new PddCore(archiviCore);
  87.             if(!pddCore.existsPddOperativa()){
  88.                 
  89.                 archiviHelper.makeMenu();
  90.                 
  91.                 pd.setMessage("Non è possibile completare l'operazione: non è stata rilevata una Porta di Dominio operativa");
  92.                 
  93.                 pd.disableEditMode();
  94.                 
  95.                 ServletUtils.setGeneralAndPageDataIntoSession(request, session, gd, pd);
  96.                 
  97.                 return ServletUtils.getStrutsForwardEditModeFinished(mapping, ArchiviCostanti.OBJECT_NAME_ARCHIVI_IMPORT, 
  98.                         ArchiviCostanti.TIPO_OPERAZIONE_IMPORT);                
  99.             }
  100.             String nomePddOperativa = pddCore.getNomePddOperativa();
  101.             
  102.             ImporterUtils importerUtils = new ImporterUtils(archiviCore);
  103.                     
  104.             
  105.             // Eventuale PostBack element name che ha scaturito l'evento
  106.             String postBackElementName = archiviHelper.getPostBackElementName();
  107.             
  108.             
  109.             // Indicazione se devo effettuare una delete od una import
  110.             boolean deleter = false;
  111.             String parametroModalitaFunzionamento = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA);
  112.             if(parametroModalitaFunzionamento!=null){
  113.                 deleter = ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA_ELIMINA.equals(parametroModalitaFunzionamento.trim());
  114.             }
  115.             else{
  116.                 // default
  117.                 parametroModalitaFunzionamento = ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA_IMPORT;
  118.             }
  119.             DataElement modalitaDataElement = new DataElement();
  120.             modalitaDataElement.setLabel(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA);
  121.             modalitaDataElement.setValue(parametroModalitaFunzionamento);
  122.             modalitaDataElement.setType(DataElementType.HIDDEN);
  123.             modalitaDataElement.setName(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA);
  124.             
  125.             
  126.             String labelBottone = ArchiviCostanti.LABEL_ARCHIVI_IMPORT;
  127.             if(deleter){
  128.                 labelBottone = ArchiviCostanti.LABEL_ARCHIVI_ELIMINA;   
  129.             }
  130.             
  131.             // parametri vari
  132.             ImporterStrutsBean strutsBean = null;
  133.             String f = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_PACKAGE_FILE_PATH);
  134.             if(f==null || "".equals(f)) {
  135.                 strutsBean = new ImporterStrutsBean(request, session, true);
  136.             }
  137.             else {
  138.                 strutsBean = new ImporterStrutsBean(request, session, false);
  139.                 strutsBean.filePath = f;
  140.             }
  141.             
  142.             // protocolli supportati
  143.             List<String> protocolli = archiviCore.getProtocolli(request, session);
  144.             if(protocolli.size()>1){
  145.                 protocolli = new ArrayList<>();
  146.                 protocolli.add(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO_UNDEFINDED);
  147.                 protocolli.addAll(archiviCore.getProtocolli(request, session));
  148.             }
  149.             strutsBean.protocollo = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO);
  150.             if("".equals(strutsBean.protocollo) || ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO_UNDEFINDED.equals(strutsBean.protocollo)){
  151.                 strutsBean.protocollo = null;
  152.             }
  153.             // Volutamente per default si vogliono tutti!
  154. /**         if(strutsBean.protocollo==null){
  155. //              strutsBean.protocollo = archiviCore.getProtocolloDefault();
  156. //          }*/
  157.             
  158.             
  159.             
  160.             // show Protocols se esiste più di un importMode per qualche protocollo
  161.             Map<String, String> importModesMapRispettoATuttiIProtocolli = importerUtils.getImportModesWithProtocol(protocolli);
  162.             boolean showProtocols = importModesMapRispettoATuttiIProtocolli!=null && importModesMapRispettoATuttiIProtocolli.size()>1;
  163.             
  164.             
  165.             
  166.             // import modes
  167.             List<String> protocolliForModes = new ArrayList<>();
  168.             if(strutsBean.protocollo!=null){
  169.                 protocolliForModes.add(strutsBean.protocollo);
  170.             }else{
  171.                 protocolliForModes.addAll(protocolli);
  172.             }
  173.             Map<String, String> importModesMap = importerUtils.getImportModesWithProtocol(protocolliForModes);
  174.             List<ImportMode> importModes = new ArrayList<>();
  175.             for (String imp : importModesMap.keySet()) {
  176.                 importModes.add(new ImportMode(imp));
  177.             }
  178.             strutsBean.importMode = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_TIPOLOGIA_ARCHIVIO);
  179.             if(strutsBean.importMode!=null &&
  180.                 // verifico che esista nei modes disponibili per i protocolli selezionati
  181.                 !importModes.contains(new ImportMode(strutsBean.importMode))){
  182.                 strutsBean.importMode = null;
  183.             }
  184.             if(strutsBean.importMode==null){
  185.                 if(importModes.contains(org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_IMPORT_ARCHIVE_MODE)){
  186.                     strutsBean.importMode = org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_IMPORT_ARCHIVE_MODE.toString();
  187.                 }else{
  188.                     strutsBean.importMode = importModes.get(0).toString();
  189.                 }
  190.             }
  191.             ImportMode archiveMode = null;
  192.             if(strutsBean.importMode!=null){
  193.                 archiveMode = new ImportMode(strutsBean.importMode);
  194.             }
  195.             
  196.             
  197.             // import types
  198.             String protocolloEffettivo = importModesMap.get(strutsBean.importMode);
  199.             /**System.out.println("PROTOCOLLO EFFETTIVO: "+protocolloEffettivo);*/
  200.             List<ArchiveModeType> importTypes = null;
  201.             if(strutsBean.importMode!=null){
  202.                 importTypes = importerUtils.getImportModeTypes(archiveMode, protocolloEffettivo);
  203.             }
  204.             strutsBean.importType = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_TIPO);
  205.             if(strutsBean.importType!=null &&
  206.                 // verifico che esista nei tyoes disponibili per il mode selezionato
  207.                 !importTypes.contains(new ArchiveModeType(strutsBean.importType))){
  208.                 strutsBean.importType = null;
  209.             }
  210.             if(strutsBean.importType==null){
  211.                 strutsBean.importType = importTypes.get(0).toString();
  212.             }
  213.             ArchiveModeType archiveModeType = null;
  214.             if(strutsBean.importType!=null){
  215.                 archiveModeType = new ArchiveModeType(strutsBean.importType);
  216.             }
  217.             
  218.             
  219.             // validazione
  220.             String tmpValidazioneDocumenti = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_VALIDAZIONE_DOCUMENTI);
  221.             if(archiviHelper.isEditModeInProgress() && tmpValidazioneDocumenti==null){
  222.                 // primo accesso alla servlet
  223.                 strutsBean.validazioneDocumenti = true;
  224.             }
  225.             else{
  226.                 if(ServletUtils.isCheckBoxEnabled(tmpValidazioneDocumenti)){
  227.                     strutsBean.validazioneDocumenti = true;
  228.                 }
  229.                 else{
  230.                     strutsBean.validazioneDocumenti = false;
  231.                 }
  232.             }
  233.             
  234.             // updateEnabled
  235.             String tmpUpdateEnabled = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_UPDATE_ENABLED);
  236.             if(archiviHelper.isEditModeInProgress() && tmpUpdateEnabled==null){
  237.                 // primo accesso alla servlet
  238.                 strutsBean.updateEnabled = false;
  239.             }
  240.             else{
  241.                 if(ServletUtils.isCheckBoxEnabled(tmpUpdateEnabled)){
  242.                     strutsBean.updateEnabled = true;
  243.                 }
  244.                 else{
  245.                     strutsBean.updateEnabled = false;
  246.                 }
  247.             }
  248.             
  249.             // importPolicyConfig
  250.             String tmpImportDeletePolicyConfig = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_DELETE_POLICY_CONFIG_ENABLED);
  251.             if(archiviHelper.isEditModeInProgress() && tmpImportDeletePolicyConfig==null){
  252.                 // primo accesso alla servlet
  253.                 strutsBean.importDeletePolicyConfig = false;
  254.             }
  255.             else{
  256.                 if(ServletUtils.isCheckBoxEnabled(tmpImportDeletePolicyConfig)){
  257.                     strutsBean.importDeletePolicyConfig = true;
  258.                 }
  259.                 else{
  260.                     strutsBean.importDeletePolicyConfig = false;
  261.                 }
  262.             }
  263.             
  264.             // importPluginConfig
  265.             String tmpImportDeletePluginConfig = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_DELETE_PLUGIN_CONFIG_ENABLED);
  266.             if(archiviHelper.isEditModeInProgress() && tmpImportDeletePluginConfig==null){
  267.                 // primo accesso alla servlet
  268.                 strutsBean.importDeletePluginConfig = false;
  269.             }
  270.             else{
  271.                 if(ServletUtils.isCheckBoxEnabled(tmpImportDeletePluginConfig)){
  272.                     strutsBean.importDeletePluginConfig = true;
  273.                 }
  274.                 else{
  275.                     strutsBean.importDeletePluginConfig = false;
  276.                 }
  277.             }
  278.             
  279.             // importConfig
  280.             String tmpImportConfig = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_CONFIG_ENABLED);
  281.             if(archiviHelper.isEditModeInProgress() && tmpImportConfig==null){
  282.                 // primo accesso alla servlet
  283.                 strutsBean.importConfig = false;
  284.             }
  285.             else{
  286.                 if(ServletUtils.isCheckBoxEnabled(tmpImportConfig)){
  287.                     strutsBean.importConfig = true;
  288.                 }
  289.                 else{
  290.                     strutsBean.importConfig = false;
  291.                 }
  292.             }
  293.             
  294.             
  295.             // importInformationMissing: objectClass
  296.             String tmpClass = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_OBJECT_CLASS);
  297.             if(tmpClass!=null && !"".equals(tmpClass)){
  298.                 strutsBean.importInformationMissingClassObject = Class.forName(tmpClass);
  299.                 String absolutePath = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_OBJECT_FILE_PATH);
  300.                 if(absolutePath==null || "".equals(absolutePath)){
  301.                     throw new ControlStationCoreException("Parametro ["+ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_OBJECT_FILE_PATH
  302.                             +"] non trovato, nonostante sia presente il parametro ["+ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_OBJECT_CLASS
  303.                             +"] con valore: "+tmpClass);
  304.                 }
  305.                 strutsBean.importInformationMissingObject = importerUtils.readImportInformationMissingObjectFile(absolutePath, strutsBean.importInformationMissingClassObject);
  306.             }else{
  307.                 strutsBean.importInformationMissingClassObject = null;
  308.                 strutsBean.importInformationMissingObject = null;
  309.             }
  310.             // importInformationMissing: soggetto
  311.             strutsBean.importInformationMissingSoggettoInput = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT);
  312.             // importInformationMissing: versione
  313.             strutsBean.importInformationMissingVersioneInput = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_VERSIONE_INPUT);
  314.             // Import Information Missing collection
  315.             strutsBean.importInformationMissingCollectionFilePath = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_COLLECTION_FILE_PATH);
  316.             // Import Information Missing object id
  317.             strutsBean.importInformationMissingObjectId = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_OBJECT_ID);
  318.             // importInformationMissing: servizi, modalita' di acquisizione
  319.             strutsBean.importInformationMissingModalitaAcquisizioneInformazioniProtocollo = 
  320.                     archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_MODALITA_ACQUISIZIONE_INPUT);
  321.             // importInformationMissing: portTypeImplemented
  322.             strutsBean.importInformationMissingPortTypeImplementedInput = 
  323.                     archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_PORT_TYPE_IMPLEMENTED_INPUT);
  324.             // importInformationMissing: accordoServizioParteComune
  325.             strutsBean.importInformationMissingAccordoServizioParteComuneInput = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_SERVIZIO_PARTE_COMUNE_INPUT);
  326.             // importInformationMissing: accordoCooperazione
  327.             strutsBean.importInformationMissingAccordoCooperazioneInput = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_COOPERAZIONE_INPUT);
  328.                         
  329.             
  330.     
  331.             
  332.                     
  333.             // File da caricare
  334.             FormFile ff = importerUtils.readFormFile(strutsBean.filePath, form);
  335.         
  336.             archiviHelper.makeMenu();
  337.             
  338.             // Se severita == null, devo visualizzare la pagina con il pulsante
  339.             if(archiviHelper.isEditModeInProgress() && 
  340.                     strutsBean.importInformationMissingModalitaAcquisizioneInformazioniProtocollo == null){
  341.                 
  342.                 // setto la barra del titolo
  343.                 String nomeFunzionalita = ArchiviCostanti.LABEL_ARCHIVI_IMPORT;
  344.                 if(deleter){
  345.                     nomeFunzionalita = ArchiviCostanti.LABEL_ARCHIVI_ELIMINA;   
  346.                 }
  347.                 ServletUtils.setPageDataTitle(pd, 
  348.                         new Parameter(nomeFunzionalita,null));

  350.                 // preparo i campi
  351.                 List<DataElement> dati = new ArrayList<>();

  353.                 dati.add(modalitaDataElement);
  354.                 
  355.                 dati.add(ServletUtils.getDataElementForEditModeFinished());

  357.                 archiviHelper.addImportToDati(dati, strutsBean.validazioneDocumenti, strutsBean.updateEnabled,
  358.                         strutsBean.importDeletePolicyConfig, 
  359.                         strutsBean.importDeletePluginConfig,
  360.                         strutsBean.importConfig,
  361.                         showProtocols, protocolli, strutsBean.protocollo, 
  362.                         importModes, strutsBean.importMode, 
  363.                         importTypes, strutsBean.importType,
  364.                         deleter);
  365.                 
  366.                 pd.setDati(dati);

  368.                 pd.setLabelBottoneInvia(labelBottone);
  369.                 
  370.                 ServletUtils.setGeneralAndPageDataIntoSession(request, session, gd, pd);
  371.                 
  372.                 return ServletUtils.getStrutsForwardEditModeInProgress(mapping, ArchiviCostanti.OBJECT_NAME_ARCHIVI_IMPORT, 
  373.                         ArchiviCostanti.TIPO_OPERAZIONE_IMPORT);
  374.             }

  376.             // Controlli sui campi immessi
  377.             boolean isOk = archiviHelper.importCheckData(ff, importerUtils, protocolloEffettivo, archiveMode, archiveModeType);
  378.                         
  379.             // Controlli su eventuali import information missing
  380.             boolean convertForGetException = false;
  381.             if(isOk && strutsBean.importInformationMissingObjectId!=null){
  382.                 isOk = archiviHelper.importInformationMissingCheckData(strutsBean.importInformationMissingSoggettoInput, strutsBean.importInformationMissingVersioneInput,
  383.                         strutsBean.importInformationMissingModalitaAcquisizioneInformazioniProtocollo, postBackElementName,
  384.                         strutsBean.importInformationMissingPortTypeImplementedInput,
  385.                         strutsBean.importInformationMissingAccordoServizioParteComuneInput,
  386.                         strutsBean.importInformationMissingAccordoCooperazioneInput);
  387.                 if(!isOk){
  388.                     convertForGetException = true;
  389.                 }
  390.             }
  391.             
  392.             // ImportInformationMissing: portTypes per accordi di servizio parte comune (profilo, correlazione per le varie azioni)
  393.             if(strutsBean.importInformationMissingModalitaAcquisizioneInformazioniProtocollo!=null && 
  394.                     !"".equals(strutsBean.importInformationMissingModalitaAcquisizioneInformazioniProtocollo)){
  395.                 try{
  396.                     strutsBean.importInformationMissingPortTypes = 
  397.                             archiviHelper.readInformazioniProtocolloServiziAzioni(strutsBean.importInformationMissingModalitaAcquisizioneInformazioniProtocollo, 
  398.                                     protocolloEffettivo, strutsBean.importInformationMissingObject);
  399.                 }catch(Exception e){
  400.                     ControlStationCore.getLog().error(e.getMessage(),e);
  401.                     pd.setMessage(e.getMessage());
  402.                     isOk = false;
  403.                     convertForGetException = false; // forzo la non ricostruzione. C'e' un errore strutturale sul package
  404.                 }
  405.             }
  406.                         
  407.             // ImportInformationMissingInvocazioneServizio
  408.             if(isOk){
  409.                 try{
  410.                     if(!archiviHelper.isEditModeInProgress()){
  411.                         strutsBean.importInformationMissingInvocazioneServizio = archiviHelper.readInvocazioneServizio();
  412.                     }
  413.                     else{
  414.                         strutsBean.importInformationMissingInvocazioneServizio = null;
  415.                     }
  416.                 }catch(Exception e){
  417.                     ControlStationCore.getLog().error(e.getMessage(),e);
  418.                     pd.setMessage(e.getMessage());
  419.                     isOk = false;
  420.                     convertForGetException = false; // forzo la non ricostruzione. C'e' un errore strutturale sul package
  421.                 }
  422.             }
  423.             
  424.             // ImportInformationMissingConnettore
  425.             if(isOk){
  426.                 try{
  427.                     if(!archiviHelper.isEditModeInProgress()){
  428.                         strutsBean.importInformationMissingConnettore = archiviHelper.readConnettore();
  429.                     }
  430.                     else{
  431.                         strutsBean.importInformationMissingConnettore = null;
  432.                     }
  433.                 }catch(Exception e){
  434.                     ControlStationCore.getLog().error(e.getMessage(),e);
  435.                     pd.setMessage(e.getMessage());
  436.                     isOk = false;
  437.                     convertForGetException = false; // forzo la non ricostruzione. C'e' un errore strutturale sul package
  438.                 }
  439.             }
  440.             
  441.             // ImportInformationMissingCredenziali
  442.             if(isOk){
  443.                 try{
  444.                     if(!archiviHelper.isEditModeInProgress()){
  445.                         strutsBean.importInformationMissingCredenziali = archiviHelper.readCredenzialiSA();
  446.                     }
  447.                     else{
  448.                         strutsBean.importInformationMissingCredenziali = null;
  449.                     }
  450.                 }catch(Exception e){
  451.                     ControlStationCore.getLog().error(e.getMessage(),e);
  452.                     pd.setMessage(e.getMessage());
  453.                     isOk = false;
  454.                     convertForGetException = false; // forzo la non ricostruzione. C'e' un errore strutturale sul package
  455.                 }
  456.             }
  457.             
  458.             // MapPlaceHolder           
  459.             MapPlaceholder importInformationMissingPlaceholder = null;
  460.             if(isOk){
  461.                 try{
  462.                     if(!archiviHelper.isEditModeInProgress()){
  463.                         importInformationMissingPlaceholder = archiviHelper.readPlaceholder();
  464.                         if(importInformationMissingPlaceholder!=null){
  465.                             strutsBean.importInformationMissingGlobalPlaceholder.putAll(importInformationMissingPlaceholder);
  466.                         }
  467.                     }
  468.                 }catch(Exception e){
  469.                     ControlStationCore.getLog().error(e.getMessage(),e);
  470.                     pd.setMessage(e.getMessage());
  471.                     isOk = false;
  472.                     convertForGetException = false; // forzo la non ricostruzione. C'e' un errore strutturale sul package
  473.                 }
  474.             }
  475.             
  476.             // Requisiti
  477.             HashMap<String, String> mapRequisitiInput = null;
  478.             HashMap<String, String> mapRequisitiInputStepIncrement = null;
  479.             if(isOk) {
  480.                 try{
  481.                     if(!archiviHelper.isEditModeInProgress()){
  482.                         mapRequisitiInput = archiviHelper.readRequisitiInput();
  483.                         mapRequisitiInputStepIncrement = archiviHelper.readRequisitiStepIncrementInput();
  484.                     }
  485.                 }catch(Exception e){
  486.                     ControlStationCore.getLog().error(e.getMessage(),e);
  487.                     pd.setMessage(e.getMessage());
  488.                     isOk = false;
  489.                     convertForGetException = false; // forzo la non ricostruzione. C'e' un errore strutturale sul package
  490.                 }
  491.             }
  492.             
  493.             // ImportInformationMissingCollection
  494.             ImportInformationMissingCollection importInformationMissingCollection = null;   
  495.             if(strutsBean.importInformationMissingCollectionFilePath!=null){
  496.                 importInformationMissingCollection = importerUtils.readImportInformationMissingCollectionFile(strutsBean.importInformationMissingCollectionFilePath);
  497.             }
  498.             if(isOk){
  499.                 importInformationMissingCollection = 
  500.                         importerUtils.updateInformationMissingCheckData(mapRequisitiInput, mapRequisitiInputStepIncrement,
  501.                                 strutsBean.importInformationMissingSoggettoInput, 
  502.                                 strutsBean.importInformationMissingVersioneInput, 
  503.                                 strutsBean.importInformationMissingPortTypes,
  504.                                 strutsBean.importInformationMissingPortTypeImplementedInput,
  505.                                 strutsBean.importInformationMissingAccordoServizioParteComuneInput,
  506.                                 strutsBean.importInformationMissingAccordoCooperazioneInput,
  507.                                 strutsBean.importInformationMissingInvocazioneServizio,
  508.                                 strutsBean.importInformationMissingConnettore,
  509.                                 strutsBean.importInformationMissingCredenziali,
  510.                                 importInformationMissingPlaceholder,
  511.                                 strutsBean.importInformationMissingCollectionFilePath, 
  512.                                 strutsBean.importInformationMissingObjectId,
  513.                                 importInformationMissingCollection);
  514.             }
  515.             
  516.             
  517.             // Step
  518.             if(!archiviHelper.isEditModeInProgress() && isOk){
  519.                 strutsBean.stepCounter.increment();
  520.             }
  521.                         
  522.             // trasformazione in archivio openspcoop2
  523.             Archive archive = null;
  524.             if(isOk || convertForGetException){
  525.                 try{
  526.                     archive = archiviCore.convert(ff.getFileData(), archiveModeType, archiveMode, protocolloEffettivo,strutsBean.validazioneDocumenti,
  527.                             strutsBean.importInformationMissingGlobalPlaceholder);
  528.                 }catch(Exception e){
  529.                     ControlStationCore.logError(e.getMessage(), e);
  530.                     pd.setMessage(e.getMessage());
  531.                     isOk = false;
  532.                 }
  533.             }
  534.             
  535.             // check requisiti wizard
  536.             if(isOk &&
  537.                 archive!=null && archive.getInformationMissing()!=null && archive.getInformationMissing().getWizard()!=null){
  538.                 try{
  539.                     isOk = archiviHelper.checkRequiisitiWizard(archive.getInformationMissing().getWizard());
  540.                 }catch(Exception e){
  541.                     ControlStationCore.logError(e.getMessage(), e);
  542.                     pd.setMessage(e.getMessage());
  543.                     isOk = false;
  544.                 }
  545.             }
  546.             
  547.             // validazione
  548.             ImportInformationMissingException importInformationMissingException = null;
  549.             if(isOk || convertForGetException){
  550.                 try{
  551.                     archiviCore.validateArchive(archive, protocolloEffettivo, 
  552.                             strutsBean.validazioneDocumenti, importInformationMissingCollection, userLogin, deleter);
  553.                 }catch(ImportInformationMissingException e){
  554.                     /**ControlStationCore.logError(importInformationMissingException.getMessage(), importInformationMissingException);*/
  555.                     importInformationMissingException = e;
  556.                     isOk = false;
  557.                 }
  558.                 catch(Exception e){
  559.                     ControlStationCore.logError(e.getMessage(), e);
  560.                     pd.setMessage(e.getMessage());
  561.                     isOk = false;
  562.                 }
  563.             }
  564.             
  565.             // finalizeArchive
  566.             if(isOk &&
  567.                 archive!=null){
  568.                 try{
  569.                     archiviCore.finalizeArchive(archive, archiveModeType, archiveMode, protocolloEffettivo,strutsBean.validazioneDocumenti,
  570.                             strutsBean.importInformationMissingGlobalPlaceholder);
  571.                 }catch(Exception e){
  572.                     ControlStationCore.logError(e.getMessage(), e);
  573.                     pd.setMessage(e.getMessage());
  574.                     isOk = false;
  575.                 }
  576.             }
  577.                         
  578.             if (!isOk) {
  579.                 
  580.                 // setto la barra del titolo
  581.                 ServletUtils.setPageDataTitle(pd, 
  582.                         new Parameter(ArchiviCostanti.LABEL_ARCHIVI_IMPORT,null));

  584.                 // preparo i campi
  585.                 List<DataElement> dati = new ArrayList<>();

  587.                 dati.add(modalitaDataElement);
  588.                 
  589.                 dati.add(ServletUtils.getDataElementForEditModeFinished());
  590.                 
  591.                 if(importInformationMissingException!=null){
  592.                 
  593.                     // Indicazione se ho letto i dati sull'InvocazioneServizio, Connettore
  594.                     boolean readedDatiConnettori = strutsBean.importInformationMissingInvocazioneServizio!=null || 
  595.                             strutsBean.importInformationMissingConnettore!=null || strutsBean.importInformationMissingCredenziali!=null;
  596.                     
  597.                     Wizard wizard = null;
  598.                     if(archive!=null && archive.getInformationMissing()!=null){
  599.                         wizard = archive.getInformationMissing().getWizard();
  600.                     }
  601.                     
  602.                     archiviHelper.addImportInformationMissingToDati(dati, importerUtils, ff, 
  603.                             strutsBean.protocollo, strutsBean.importMode, protocolloEffettivo, strutsBean.importType, 
  604.                             strutsBean.validazioneDocumenti, strutsBean.updateEnabled,
  605.                             strutsBean.importDeletePolicyConfig, 
  606.                             strutsBean.importDeletePluginConfig,
  607.                             strutsBean.importConfig,
  608.                             importInformationMissingCollection, importInformationMissingException, 
  609.                             strutsBean.importInformationMissingModalitaAcquisizioneInformazioniProtocollo,strutsBean.importInformationMissingPortTypes,
  610.                             protocolliForModes,readedDatiConnettori,
  611.                             wizard,strutsBean.stepCounter.getStep(),
  612.                             deleter);
  613.                     
  614.                     pd.setLabelBottoneInvia(ArchiviCostanti.LABEL_ARCHIVI_AVANTI);
  615.                 }
  616.                 else{
  617.                     archiviHelper.addImportToDati(dati, strutsBean.validazioneDocumenti, strutsBean.updateEnabled,
  618.                             strutsBean.importDeletePolicyConfig, 
  619.                             strutsBean.importDeletePluginConfig,
  620.                             strutsBean.importConfig,
  621.                             showProtocols, protocolli, strutsBean.protocollo, 
  622.                             importModes, strutsBean.importMode, 
  623.                             importTypes, strutsBean.importType,
  624.                             deleter);
  625.                     
  626.                     pd.setLabelBottoneInvia(labelBottone);
  627.                 }
  628.                 
  629.                 pd.setDati(dati);

  631.                 if(pd.getMessage()!=null &&
  632.                     importInformationMissingException==null){
  633.                     pd.setMessage(ArchiviCostanti.LABEL_IMPORT_ERROR_HEADER+StringEscapeUtils.escapeHtml(pd.getMessage()));
  634.                 }
  635.                 
  636.                 ServletUtils.setGeneralAndPageDataIntoSession(request, session, gd, pd);
  637.                 
  638.                 return ServletUtils.getStrutsForwardEditModeCheckError(mapping, ArchiviCostanti.OBJECT_NAME_ARCHIVI_IMPORT, 
  639.                         ArchiviCostanti.TIPO_OPERAZIONE_IMPORT);
  640.             }
  641.                         
  642.             

  644.             
  645.             
  646.             
  647.             List<DataElement> dati = new ArrayList<>();

  649.             dati.add(ServletUtils.getDataElementForEditModeFinished());
  650.             
  651.             /**
  652.             System.out.println("IMPORT COME PROTOCOL["+protocolloEffettivo+"] MODE["+strutsBean.importMode+"] TIPO["+
  653.                     strutsBean.importType+"]");
  654.             
  655.             if(importInformationMissingCollection!=null){
  656.                 System.out.println("SIZE COLLECTION ["+importInformationMissingCollection.size()+"]");
  657.                 Enumeration<String> keys = importInformationMissingCollection.keys();
  658.                 while (keys.hasMoreElements()) {
  659.                     String key = (String) keys.nextElement();
  660.                     ImportInformationMissing i = importInformationMissingCollection.get(key);
  661.                     System.out.println("COLLECTION ["+key
  662.                             +"] soggetti["+i.getSoggetto()+"] versione["+i.getVersione()
  663.                             +"] portTypes["+i.getPortTypes().size()+"]");
  664.                 }
  665.             }
  666.             */
  667.             
  668.             String esito = null;
  669.             if(deleter){
  670.                 esito = archiviCore.deleteArchive(archive, archiveMode, protocolloEffettivo, 
  671.                         userLogin, archiviHelper.smista(),
  672.                         strutsBean.importDeletePolicyConfig,
  673.                         strutsBean.importDeletePluginConfig);
  674.             }else{
  675.                 esito = archiviCore.importArchive(archive, archiveMode, protocolloEffettivo, 
  676.                         userLogin, archiviHelper.smista(), 
  677.                         strutsBean.updateEnabled, 
  678.                         strutsBean.importDeletePolicyConfig, 
  679.                         strutsBean.importDeletePluginConfig, archiviCore.isConfigurazionePluginsEnabled(),
  680.                         strutsBean.importConfig, nomePddOperativa,
  681.                         archiviHelper);
  682.             }
  683.                                     
  684.             dati.add(modalitaDataElement);
  685.             
  686.             DataElement de = new DataElement();
  687.             de.setLabel("Riepilogo Configurazioni Effettuate");
  688.             de.setType(DataElementType.TITLE);
  689.             dati.add(de);
  690.             
  691.             de = new DataElement();
  692.             de.setLabel("");
  693.             de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  694.             de.setValue(esito);
  695.             de.setName("Resoconto");
  696.             de.setRows(30);
  697.             de.setCols(130);
  698.             dati.add(de);
  699.             
  700.             if(esito!=null && !"".equals(esito)){
  701.                 
  702.                 // Salvo resoconto per fornirlo alla servlet
  703.                 ServletUtils.setObjectIntoSession(request, session, esito, ArchiviCostanti.PARAMETRO_DOWNLOAD_RESOCONTO_VALORE);
  704.                 
  705.                 DataElement saveAs = new DataElement();
  706.                 saveAs.setValue(ArchiviCostanti.LABEL_DOWNLOAD);
  707.                 saveAs.setType(DataElementType.LINK);
  708.                 saveAs.setUrl(ArchiviCostanti.SERVLET_NAME_RESOCONTO_EXPORT);
  709.                 saveAs.setDisabilitaAjaxStatus();
  710.                 dati.add(saveAs);
  711.             }
  712.             
  713.             pd.disableEditMode();
  714.     
  715.             pd.setDati(dati);
  716.             
  717.             ServletUtils.setGeneralAndPageDataIntoSession(request, session, gd, pd);
  718.             
  719.             return ServletUtils.getStrutsForwardEditModeFinished(mapping, ArchiviCostanti.OBJECT_NAME_ARCHIVI_IMPORT, 
  720.                     ArchiviCostanti.TIPO_OPERAZIONE_IMPORT);
  721.             
  722.         } catch (Exception e) {
  723.             return ServletUtils.getStrutsForwardError(ControlStationCore.getLog(), e, pd, request, session, gd, mapping, 
  724.                     ArchiviCostanti.OBJECT_NAME_ARCHIVI_IMPORT,
  725.                     ArchiviCostanti.TIPO_OPERAZIONE_IMPORT);
  726.         }
  727.         
  728.     }
  729.     
  730. }
Created with JaCoCo 0.8.8.202204050719