ImporterInformationMissingUtils.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.protocol.engine.archive;

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

  28. import javax.xml.namespace.QName;

  30. import org.openspcoop2.core.config.Credenziali;
  31. import org.openspcoop2.core.config.InvocazioneServizio;
  32. import org.openspcoop2.core.config.PortaApplicativa;
  33. import org.openspcoop2.core.config.PortaDelegata;
  34. import org.openspcoop2.core.config.ServizioApplicativo;
  35. import org.openspcoop2.core.id.IDAccordo;
  36. import org.openspcoop2.core.id.IDAccordoCooperazione;
  37. import org.openspcoop2.core.id.IDServizio;
  38. import org.openspcoop2.core.id.IDSoggetto;
  39. import org.openspcoop2.core.registry.AccordoCooperazione;
  40. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  41. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  42. import org.openspcoop2.core.registry.Connettore;
  43. import org.openspcoop2.core.registry.Fruitore;
  44. import org.openspcoop2.core.registry.IdSoggetto;
  45. import org.openspcoop2.core.registry.Operation;
  46. import org.openspcoop2.core.registry.PortType;
  47. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  48. import org.openspcoop2.core.registry.constants.TipologiaServizio;
  49. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  50. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  51. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  52. import org.openspcoop2.message.xml.MessageXMLUtils;
  53. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  54. import org.openspcoop2.protocol.engine.constants.Costanti;
  55. import org.openspcoop2.protocol.information_missing.ConditionType;
  56. import org.openspcoop2.protocol.information_missing.ConditionsType;
  57. import org.openspcoop2.protocol.information_missing.Openspcoop2;
  58. import org.openspcoop2.protocol.information_missing.Operazione;
  59. import org.openspcoop2.protocol.information_missing.ProprietaRequisitoInput;
  60. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  61. import org.openspcoop2.protocol.sdk.ProtocolException;
  62. import org.openspcoop2.protocol.sdk.archive.Archive;
  63. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoCooperazione;
  64. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioComposto;
  65. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteComune;
  66. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
  67. import org.openspcoop2.protocol.sdk.archive.ArchiveFruitore;
  68. import org.openspcoop2.protocol.sdk.archive.ArchivePortaApplicativa;
  69. import org.openspcoop2.protocol.sdk.archive.ArchivePortaDelegata;
  70. import org.openspcoop2.protocol.sdk.archive.ArchiveServizioApplicativo;
  71. import org.openspcoop2.protocol.sdk.archive.ArchiveSoggetto;
  72. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  73. import org.openspcoop2.protocol.sdk.validator.IValidazioneDocumenti;
  74. import org.openspcoop2.protocol.sdk.validator.ValidazioneResult;
  75. import org.openspcoop2.utils.wsdl.DefinitionWrapper;
  76. import org.openspcoop2.utils.xml.AbstractXMLUtils;
  77. import org.w3c.dom.Document;

  79. /**
  80.  * ImporterInformationMissingUtils
  81.  * 
  82.  * @author Andrea Poli (apoli@link.it)
  83.  * @author $Author$
  84.  * @version $Rev$, $Date$
  85.  */
  86. public class ImporterInformationMissingUtils {

  88.     private IDAccordoCooperazioneFactory idAccordoCooperazioneFactory = null;
  89.     private IDAccordoFactory idAccordoFactory = null;
  90.     private IDServizioFactory idServizioFactory = null;
  91.     private ImportInformationMissingCollection importInformationMissingCollection = null;
  92.     private boolean validateDocuments = false;
  93.     private IProtocolFactory<?> protocolFactory;
  94.     private IValidazioneDocumenti validatoreDocumenti;
  95.     private AbstractXMLUtils xmlUtils;
  96.     private IRegistryReader registryReader;
  97.     private Archive archive;
  98.     private ProtocolFactoryManager protocolFactoryManager;
  99.     
  100.     public ImporterInformationMissingUtils(ImportInformationMissingCollection importInformationMissingCollection,IRegistryReader registryReader,
  101.             boolean validateDocuments,IProtocolFactory<?> protocolFactory, String userLogin, Archive archive) throws Exception{
  102.         this.idAccordoCooperazioneFactory = IDAccordoCooperazioneFactory.getInstance();
  103.         this.idAccordoFactory = IDAccordoFactory.getInstance();
  104.         this.idServizioFactory = IDServizioFactory.getInstance();
  105.         this.importInformationMissingCollection = importInformationMissingCollection;
  106.         this.validateDocuments = validateDocuments;
  107.         this.protocolFactory = protocolFactory;
  108.         this.validatoreDocumenti = this.protocolFactory.createValidazioneDocumenti();
  109.         this.xmlUtils = MessageXMLUtils.DEFAULT;
  110.         this.registryReader = registryReader;
  111.         this.archive = archive;
  112.         this.protocolFactoryManager = ProtocolFactoryManager.getInstance();
  113.     }
  114.     
  115.     
  116.     
  117.     public void validateAndFillInformationMissing(Openspcoop2 archiveInformationMissingWizard, boolean delete) throws Exception{
  118.         
  119.         ImportInformationMissingException infoException = null; 
  120.         String objectId = null;
  121.         String objectIdDescription = null;
  122.         ImportInformationMissing importInformationMissing = null;
  123.         boolean throwException = false;
  124.         try{
  125.         
  126.             // -------- requisiti --------------
  127.             if(!throwException && archiveInformationMissingWizard.getWizard()!=null && 
  128.                     archiveInformationMissingWizard.getWizard().getRequisiti()!=null &&
  129.                             archiveInformationMissingWizard.getWizard().getRequisiti().getInput()!=null &&
  130.                             archiveInformationMissingWizard.getWizard().getRequisiti().getInput().sizeProprietaList()>0) {
  131.                 
  132.                 boolean existsRequisitiInput = false;
  133.                 for (ProprietaRequisitoInput pInput : archiveInformationMissingWizard.getWizard().getRequisiti().getInput().getProprietaList()) {
  134.                     if(!delete || pInput.isUseInDelete()) {
  135.                         existsRequisitiInput = true;
  136.                         break;
  137.                     }
  138.                 }
  139.                 
  140.                 if(existsRequisitiInput) {
  141.                 
  142.                     // *** object id ***
  143.                     
  144.                     importInformationMissing = null;
  145.                     objectId = Costanti.REQUISITI_INPUT_RACCOLTI; 
  146.                     objectIdDescription = archiveInformationMissingWizard.getWizard().getRequisiti().getInput().getDescrizione();   
  147.                     if(this.importInformationMissingCollection!=null){
  148.                         importInformationMissing = this.importInformationMissingCollection.get(objectId);
  149.                     }
  150.                     
  151.                     // *** campi da verificare ***
  152.                     if(importInformationMissing==null || importInformationMissing.getRequisitiInput()==null || importInformationMissing.getRequisitiInput().isEmpty()){
  153.                         infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  154.                         infoException.setMissingRequisitiInfoInput(true);
  155.                         infoException.setMissingRequisitiInfoInputObject(archiveInformationMissingWizard.getWizard().getRequisiti().getInput());
  156.                         throwException = true;
  157.                     }
  158.                         
  159.                     if(throwException) {
  160.                         throw infoException;
  161.                     }
  162.                 
  163.                 }
  164.                 
  165.             }
  166.             
  167.             HashMap<String, String> requisitiInput = null;
  168.             if(this.importInformationMissingCollection!=null && this.importInformationMissingCollection.exists(org.openspcoop2.protocol.engine.constants.Costanti.REQUISITI_INPUT_RACCOLTI)) {
  169.                 ImportInformationMissing miss = this.importInformationMissingCollection.get(org.openspcoop2.protocol.engine.constants.Costanti.REQUISITI_INPUT_RACCOLTI);
  170.                 if(miss!=null) {
  171.                     requisitiInput = miss.getRequisitiInput();
  172.                 }
  173.             }
  174.             
  175.             
  176.             
  177.             int indexInputPage = 0; 
  178.             
  179.             for (Operazione  archiveInformationMissing: archiveInformationMissingWizard.getOperazioneList()) {
  180.             
  181.                 indexInputPage ++;
  182.                 
  183.                 if(throwException) {
  184.                     break;
  185.                 }
  186.             
  187.                 
  188.                 // -------- Accordi di Servizio Parte Comune (Gestione Referente nei protocolli che non lo supportano) --------
  189.                 ImporterInformationMissingSetter.setInformationMissingReferenteAPI(this.archive, this.registryReader);
  190.                 
  191.                 
  192.                 
  193.                 // -------- soggetto --------------
  194.                 
  195.                 if(!throwException && archiveInformationMissing.sizeSoggettoList()>0){
  196.                     for (int i = 0; i < archiveInformationMissing.sizeSoggettoList(); i++) {
  197.                         org.openspcoop2.protocol.information_missing.Soggetto soggettoMissingInfo = 
  198.                                 archiveInformationMissing.getSoggetto(i);
  199.                 
  200.                         if(soggettoMissingInfo.getConditions()!=null) {
  201.                             if(checkConditions(soggettoMissingInfo.getConditions(),requisitiInput)==false) {
  202.                                 continue;
  203.                             }
  204.                         }
  205.                         
  206.                         
  207.                         // *** object id ***
  208.                         
  209.                         importInformationMissing = null;
  210.                         objectId = "[[InformationMissingSoggetto-"+indexInputPage+"-"+i+"]]"; 
  211.                         objectIdDescription = soggettoMissingInfo.getDescrizione(); 
  212.                         if(this.importInformationMissingCollection!=null){
  213.                             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  214.                         }
  215.                         
  216.                         // *** campi da verificare ***
  217.                         boolean updateInfo = false;
  218.                         switch (soggettoMissingInfo.getTipo()) {
  219.                         case RIFERIMENTO:
  220.                             if(importInformationMissing!=null && importInformationMissing.getSoggetto()!=null){
  221.                                 if(!this.registryReader.existsSoggetto(importInformationMissing.getSoggetto())){
  222.                                     // verifico che non esista nell'archivio che sto importanto
  223.                                     boolean found = false;
  224.                                     if(this.archive.getSoggetti()!=null && this.archive.getSoggetti().size()>0){
  225.                                         for (int j = 0; j < this.archive.getSoggetti().size(); j++) {
  226.                                             ArchiveSoggetto archiveSoggetto = this.archive.getSoggetti().get(j);
  227.                                             if(archiveSoggetto.getIdSoggetto().equals(importInformationMissing.getSoggetto())){
  228.                                                 found = true;
  229.                                                 break;
  230.                                             }
  231.                                         }
  232.                                     }
  233.                                     if(!found){
  234.                                         throw new ProtocolException("Il Soggetto "+importInformationMissing.getSoggetto().toString()+" non esiste (indicato in ImportInformationMissing parameter??)");
  235.                                     }
  236.                                 }
  237.                                 updateInfo = true;
  238.                             }else{
  239.                                 infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  240.                                 infoException.setMissingInfoSoggetto(true);
  241.                                 if(soggettoMissingInfo.getTipoPdd()!=null)
  242.                                     infoException.setMissingInfoSoggetto_tipoPdD(soggettoMissingInfo.getTipoPdd().getValue());
  243.                                 throwException = true;
  244.                             }   
  245.                             break;
  246.                         case CONNETTORE:
  247.                             if(delete==false) {
  248.                                 if(importInformationMissing!=null && importInformationMissing.getInvocazioneServizio()!=null){
  249.                                     updateInfo = true;
  250.                                 }
  251.                                 else{
  252.                                     infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  253.                                     infoException.setMissingInfoInvocazioneServizio(true);
  254.                                     if(soggettoMissingInfo.getTipoPdd()!=null)
  255.                                         infoException.setMissingInfoSoggetto_tipoPdD(soggettoMissingInfo.getTipoPdd().getValue());  
  256.                                     throwException = true;
  257.                                 }
  258.                             }
  259.                             break;
  260.                         }
  261.                         if(infoException!=null) {
  262.                             infoException.setMissingInfoProtocollo(soggettoMissingInfo.getProtocollo());
  263.                             infoException.setMissingInfoHeader(soggettoMissingInfo.getHeader());
  264.                             infoException.setMissingInfoFooter(soggettoMissingInfo.getFooter());
  265.                             infoException.setMissingInfoDefault(soggettoMissingInfo.getDefault());
  266.                         }
  267.                         
  268.                         if(!throwException && updateInfo){
  269.                             // Se non sono state lanciate eccezioni a questo punto posso usare le informazioni salvate di information missing per riempire
  270.                             // le informazioni mancanti negli altri archivi, altrimenti poi i metodi sottostanti lanceranno le relative informazioni
  271.                             // di information missing
  272.                             IDSoggetto importInformationMissing_soggetto = null;
  273.                             Connettore importInformationMissing_connettore = null;
  274.                             if(importInformationMissing!=null){
  275.                                 importInformationMissing_soggetto = importInformationMissing.getSoggetto();
  276.                                 importInformationMissing_connettore = importInformationMissing.getConnettore();
  277.                             }
  278.                             ImporterInformationMissingSetter.setInformationMissingSoggetto(this.archive, soggettoMissingInfo, 
  279.                                     importInformationMissing_soggetto, importInformationMissing_connettore);
  280.                         }
  281.                         else{
  282.                             break;
  283.                         }
  284.                         
  285.                     }
  286.                 }
  287.                 
  288.                 // -------- input --------------
  289.                 
  290.                 if(!throwException && archiveInformationMissing.sizeInputList()>0){
  291.                     for (int i = 0; i < archiveInformationMissing.sizeInputList(); i++) {
  292.                         org.openspcoop2.protocol.information_missing.Input inputMissingInfo = 
  293.                                 archiveInformationMissing.getInput(i);
  294.                         if(delete) {
  295.                             boolean foundPropertyUseInDelete = false;
  296.                             for (int j = 0; j < inputMissingInfo.sizeProprietaList(); j++) {
  297.                                 if(inputMissingInfo.getProprieta(j).isUseInDelete()) {
  298.                                     foundPropertyUseInDelete = true;
  299.                                     break;
  300.                                 }
  301.                             }
  302.                             if(!foundPropertyUseInDelete) {
  303.                                 continue;
  304.                             }
  305.                         }
  306.                 
  307.                         if(inputMissingInfo.getConditions()!=null) {
  308.                             if(checkConditions(inputMissingInfo.getConditions(),requisitiInput)==false) {
  309.                                 continue;
  310.                             }
  311.                         }
  312.                         
  313.                         // *** object id ***
  314.                         
  315.                         importInformationMissing = null;
  316.                         objectId = "[[InformationMissingInput-"+indexInputPage+"-"+i+"]]"; 
  317.                         objectIdDescription = inputMissingInfo.getDescrizione();    
  318.                         if(this.importInformationMissingCollection!=null){
  319.                             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  320.                         }
  321.                         
  322.                         // *** campi da verificare ***
  323.                         if(importInformationMissing==null || importInformationMissing.getInputPlaceholder()==null){
  324.                             infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  325.                             infoException.setMissingInfoInput(true);
  326.                             infoException.setMissingInfoInputObject(inputMissingInfo);
  327.                             throwException = true;
  328.                         }
  329.                             
  330.                         if(throwException) {
  331.                             break;
  332.                         }
  333.                         
  334.                     }
  335.                 }
  336.                 
  337.                 // -------- servizioApplicativo --------------
  338.                         
  339.                 if(!throwException && archiveInformationMissing.sizeServizioApplicativoList()>0){
  340.                     for (int i = 0; i < archiveInformationMissing.sizeServizioApplicativoList(); i++) {
  341.                         org.openspcoop2.protocol.information_missing.ServizioApplicativo saMissingInfo = 
  342.                                 archiveInformationMissing.getServizioApplicativo(i);
  343.                         
  344.                         if(saMissingInfo.getConditions()!=null) {
  345.                             if(checkConditions(saMissingInfo.getConditions(),requisitiInput)==false) {
  346.                                 continue;
  347.                             }
  348.                         }
  349.                         
  350.                         // *** object id ***
  351.                         
  352.                         importInformationMissing = null;
  353.                         objectId = "[[InformationMissingServizioApplicativo-"+indexInputPage+"-"+i+"]]"; 
  354.                         objectIdDescription = saMissingInfo.getDescrizione();   
  355.                         if(this.importInformationMissingCollection!=null){
  356.                             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  357.                         }
  358.                         
  359.                         // *** campi da verificare ***
  360.                         boolean updateInfo = false;
  361.                         switch (saMissingInfo.getTipo()) {
  362.                         case RIFERIMENTO:
  363.                             // nop; non gestito (Da realizzare per assegnare lo stesso servizio applicativo a piu' porte)
  364.                             break;
  365.                         case CONNETTORE:
  366.                             if(delete==false) {
  367.                                 if(importInformationMissing!=null && importInformationMissing.getInvocazioneServizio()!=null){
  368.                                     updateInfo = true;
  369.                                 }
  370.                                 else{
  371.                                     infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  372.                                     infoException.setMissingInfoInvocazioneServizio(true);
  373.                                     throwException = true;
  374.                                 }
  375.                             }
  376.                             break;
  377.                         case CREDENZIALI_ACCESSO_PDD:
  378.                             if(delete==false) {
  379.                                 if(importInformationMissing!=null && importInformationMissing.getCredenziali()!=null){
  380.                                     updateInfo = true;
  381.                                 }
  382.                                 else{
  383.                                     infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  384.                                     infoException.setMissingInfoCredenziali(true);
  385.                                     throwException = true;
  386.                                 }
  387.                             }
  388.                             break;
  389.                         case ALLINEA_CREDENZIALI_PD:
  390.                             if(delete==false) {
  391.                                 updateInfo = true;
  392.                             }
  393.                             break;
  394.                         }
  395.                         if(infoException!=null) {
  396.                             infoException.setMissingInfoProtocollo(saMissingInfo.getProtocollo());
  397.                             infoException.setMissingInfoHeader(saMissingInfo.getHeader());
  398.                             infoException.setMissingInfoFooter(saMissingInfo.getFooter());
  399.                             infoException.setMissingInfoDefault(saMissingInfo.getDefault());
  400.                         }
  401.                         
  402.                         if(!throwException && updateInfo){
  403.                             // Se non sono state lanciate eccezioni a questo punto posso usare le informazioni salvate di information missing per riempire
  404.                             // le informazioni mancanti negli altri archivi, altrimenti poi i metodi sottostanti lanceranno le relative informazioni
  405.                             // di information missing
  406.                             InvocazioneServizio importInformationMissing_invocazioneServizio = null;
  407.                             Credenziali importInformationMissing_credenziali = null;
  408.                             if(importInformationMissing!=null){
  409.                                 importInformationMissing_invocazioneServizio = importInformationMissing.getInvocazioneServizio();
  410.                                 importInformationMissing_credenziali = importInformationMissing.getCredenziali();
  411.                             }
  412.                             ImporterInformationMissingSetter.setInformationMissingServizioApplicativo(this.archive, saMissingInfo, 
  413.                                     importInformationMissing_invocazioneServizio,importInformationMissing_credenziali);
  414.                         }
  415.                         else{
  416.                             break;
  417.                         }
  418.                     }           
  419.                 }
  420.                 
  421.                 // -------- accordiCooperazione --------------
  422.                 
  423.                 if(!throwException && archiveInformationMissing.sizeAccordoCooperazioneList()>0){
  424.                     for (int i = 0; i < archiveInformationMissing.sizeAccordoCooperazioneList(); i++) {
  425.                         org.openspcoop2.protocol.information_missing.AccordoCooperazione acMissingInfo = 
  426.                                 archiveInformationMissing.getAccordoCooperazione(i);
  427.                         
  428.                         if(acMissingInfo.getConditions()!=null) {
  429.                             if(checkConditions(acMissingInfo.getConditions(),requisitiInput)==false) {
  430.                                 continue;
  431.                             }
  432.                         }
  433.                         
  434.                         // *** object id ***
  435.                         
  436.                         importInformationMissing = null;
  437.                         objectId = "[[InformationMissingAccordoCooperazione-"+indexInputPage+"-"+i+"]]"; 
  438.                         objectIdDescription = acMissingInfo.getDescrizione();   
  439.                         if(this.importInformationMissingCollection!=null){
  440.                             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  441.                         }
  442.                         
  443.                         // *** campi da verificare ***
  444.                         boolean updateInfo = false;
  445.                         switch (acMissingInfo.getTipo()) {
  446.                         case RIFERIMENTO:
  447.                             if(importInformationMissing!=null && importInformationMissing.getIdAccordoCooperazione()!=null){
  448.                                 updateInfo = true;
  449.                             }
  450.                             else{
  451.                                 infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  452.                                 infoException.setMissingInfoAccordoCooperazione(true);
  453.                                 throwException = true;
  454.                             }
  455.                             break;
  456.                         case STATO_ARCHIVIO:
  457.                             if(delete==false) {
  458.                                 updateInfo = true;
  459.                             }
  460.                             break;
  461.                         }
  462.                         if(infoException!=null) {
  463.                             infoException.setMissingInfoProtocollo(acMissingInfo.getProtocollo());
  464.                             infoException.setMissingInfoHeader(acMissingInfo.getHeader());
  465.                             infoException.setMissingInfoFooter(acMissingInfo.getFooter());
  466.                             infoException.setMissingInfoDefault(acMissingInfo.getDefault());
  467.                         }
  468.                         
  469.                         if(!throwException && updateInfo){
  470.                             // Se non sono state lanciate eccezioni a questo punto posso usare le informazioni salvate di information missing per riempire
  471.                             // le informazioni mancanti negli altri archivi, altrimenti poi i metodi sottostanti lanceranno le relative informazioni
  472.                             // di information missing
  473.                             IDAccordoCooperazione importInformationMissing_idAccordoCooperazione = null;
  474.                             if(importInformationMissing!=null){
  475.                                 importInformationMissing_idAccordoCooperazione = importInformationMissing.getIdAccordoCooperazione();
  476.                             }
  477.                             ImporterInformationMissingSetter.setInformationMissingAccordoCooperazione(this.archive, acMissingInfo, 
  478.                                     importInformationMissing_idAccordoCooperazione);
  479.                         }
  480.                         else{
  481.                             break;
  482.                         }
  483.                     }           
  484.                 }
  485.                 
  486.                 
  487.                 // -------- accordiServizioParteComune --------------
  488.                 
  489.                 if(!throwException && archiveInformationMissing.sizeAccordoServizioParteComuneList()>0){
  490.                     for (int i = 0; i < archiveInformationMissing.sizeAccordoServizioParteComuneList(); i++) {
  491.                         org.openspcoop2.protocol.information_missing.AccordoServizioParteComune asMissingInfo = 
  492.                                 archiveInformationMissing.getAccordoServizioParteComune(i);
  493.                         
  494.                         if(asMissingInfo.getConditions()!=null) {
  495.                             if(checkConditions(asMissingInfo.getConditions(),requisitiInput)==false) {
  496.                                 continue;
  497.                             }
  498.                         }
  499.                         
  500.                         // *** object id ***
  501.                         
  502.                         importInformationMissing = null;
  503.                         objectId = "[[InformationMissingAccordoServizioParteComune-"+indexInputPage+"-"+i+"]]"; 
  504.                         objectIdDescription = asMissingInfo.getDescrizione();   
  505.                         if(this.importInformationMissingCollection!=null){
  506.                             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  507.                         }
  508.                         
  509.                         // *** campi da verificare ***
  510.                         boolean updateInfo = false;
  511.                         switch (asMissingInfo.getTipo()) {
  512.                         case RIFERIMENTO:
  513.                             if(importInformationMissing!=null && importInformationMissing.getIdAccordoServizioParteComune()!=null){
  514.                                 updateInfo = true;
  515.                             }
  516.                             else{
  517.                                 infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  518.                                 infoException.setMissingInfoAccordoServizioParteComune(true);
  519.                                 throwException = true;
  520.                             }
  521.                             break;
  522.                         case STATO_ARCHIVIO:
  523.                             if(delete==false) {
  524.                                 updateInfo = true;
  525.                             }
  526.                             break;
  527.                         }
  528.                         if(infoException!=null) {
  529.                             infoException.setMissingInfoProtocollo(asMissingInfo.getProtocollo());
  530.                             infoException.setMissingInfoHeader(asMissingInfo.getHeader());
  531.                             infoException.setMissingInfoFooter(asMissingInfo.getFooter());
  532.                             infoException.setMissingInfoDefault(asMissingInfo.getDefault());
  533.                         }
  534.                         
  535.                         if(!throwException && updateInfo){
  536.                             // Se non sono state lanciate eccezioni a questo punto posso usare le informazioni salvate di information missing per riempire
  537.                             // le informazioni mancanti negli altri archivi, altrimenti poi i metodi sottostanti lanceranno le relative informazioni
  538.                             // di information missing
  539.                             IDAccordo importInformationMissing_idAccordo = null;
  540.                             if(importInformationMissing!=null){
  541.                                 importInformationMissing_idAccordo = importInformationMissing.getIdAccordoServizioParteComune();
  542.                             }
  543.                             ImporterInformationMissingSetter.setInformationMissingAccordoServizioParteComune(this.archive, asMissingInfo, 
  544.                                     importInformationMissing_idAccordo);
  545.                         }
  546.                         else{
  547.                             break;
  548.                         }
  549.                     }           
  550.                 }
  551.                 
  552.                 
  553.                 // -------- accordoServizioParteSpecifica --------------
  554.                 
  555.                 if(!throwException && archiveInformationMissing.sizeAccordoServizioParteSpecificaList()>0){
  556.                     for (int i = 0; i < archiveInformationMissing.sizeAccordoServizioParteSpecificaList(); i++) {
  557.                         org.openspcoop2.protocol.information_missing.AccordoServizioParteSpecifica aspsMissingInfo = 
  558.                                 archiveInformationMissing.getAccordoServizioParteSpecifica(i);
  559.                         
  560.                         if(aspsMissingInfo.getConditions()!=null) {
  561.                             if(checkConditions(aspsMissingInfo.getConditions(),requisitiInput)==false) {
  562.                                 continue;
  563.                             }
  564.                         }
  565.                         
  566.                         // *** object id ***
  567.                         
  568.                         importInformationMissing = null;
  569.                         objectId = "[[InformationMissingAPS-"+indexInputPage+"-"+i+"]]"; 
  570.                         objectIdDescription = aspsMissingInfo.getDescrizione(); 
  571.                         if(this.importInformationMissingCollection!=null){
  572.                             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  573.                         }
  574.                         
  575.                         // *** campi da verificare ***
  576.                         boolean updateInfo = false;
  577.                         switch (aspsMissingInfo.getTipo()) {
  578.                         case CONNETTORE:
  579.                             if(delete==false) {
  580.                                 if(importInformationMissing!=null && importInformationMissing.getConnettore()!=null){
  581.                                     updateInfo = true;
  582.                                 }
  583.                                 else{
  584.                                     infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  585.                                     infoException.setMissingInfoConnettore(true);
  586.                                     throwException = true;
  587.                                 }
  588.                             }
  589.                             break;
  590.                         case STATO_ARCHIVIO:
  591.                             if(delete==false) {
  592.                                 updateInfo = true;
  593.                             }
  594.                             break;
  595.                         }
  596.                         if(infoException!=null) {
  597.                             infoException.setMissingInfoProtocollo(aspsMissingInfo.getProtocollo());
  598.                             infoException.setMissingInfoHeader(aspsMissingInfo.getHeader());
  599.                             infoException.setMissingInfoFooter(aspsMissingInfo.getFooter());
  600.                             infoException.setMissingInfoDefault(aspsMissingInfo.getDefault());
  601.                         }
  602.                         
  603.                         if(!throwException && updateInfo){
  604.                             // Se non sono state lanciate eccezioni a questo punto posso usare le informazioni salvate di information missing per riempire
  605.                             // le informazioni mancanti negli altri archivi, altrimenti poi i metodi sottostanti lanceranno le relative informazioni
  606.                             // di information missing
  607.                             Connettore importInformationMissing_connettore = null;
  608.                             if(importInformationMissing!=null){
  609.                                 importInformationMissing_connettore = importInformationMissing.getConnettore();
  610.                             }
  611.                             ImporterInformationMissingSetter.setInformationMissingAccordoServizioParteSpecifica(this.archive, aspsMissingInfo, 
  612.                                     importInformationMissing_connettore);
  613.                         }
  614.                         else{
  615.                             break;
  616.                         }
  617.                     }           
  618.                 }
  619.     
  620.                 // -------- accordiServizioComposto --------------
  621.                 
  622.                 if(!throwException && archiveInformationMissing.sizeAccordoServizioCompostoList()>0){
  623.                     for (int i = 0; i < archiveInformationMissing.sizeAccordoServizioCompostoList(); i++) {
  624.                         org.openspcoop2.protocol.information_missing.AccordoServizioParteComune asMissingInfo = 
  625.                                 archiveInformationMissing.getAccordoServizioComposto(i);
  626.                         
  627.                         if(asMissingInfo.getConditions()!=null) {
  628.                             if(checkConditions(asMissingInfo.getConditions(),requisitiInput)==false) {
  629.                                 continue;
  630.                             }
  631.                         }
  632.                         
  633.                         // *** object id ***
  634.                         
  635.                         importInformationMissing = null;
  636.                         objectId = "[[InformationMissingAccordoServizioComposto-"+indexInputPage+"-"+i+"]]"; 
  637.                         objectIdDescription = asMissingInfo.getDescrizione();   
  638.                         if(this.importInformationMissingCollection!=null){
  639.                             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  640.                         }
  641.                         
  642.                         // *** campi da verificare ***
  643.                         boolean updateInfo = false;
  644.                         switch (asMissingInfo.getTipo()) {
  645.                         case RIFERIMENTO:
  646.                             if(importInformationMissing!=null && importInformationMissing.getIdAccordoServizioParteComune()!=null){
  647.                                 updateInfo = true;
  648.                             }
  649.                             else{
  650.                                 infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  651.                                 infoException.setMissingInfoAccordoServizioParteComune(true);
  652.                                 throwException = true;
  653.                             }
  654.                             break;
  655.                         case STATO_ARCHIVIO:
  656.                             if(delete==false) {
  657.                                 updateInfo = true;
  658.                             }
  659.                             break;
  660.                         }
  661.                         if(infoException!=null) {
  662.                             infoException.setMissingInfoProtocollo(asMissingInfo.getProtocollo());
  663.                             infoException.setMissingInfoHeader(asMissingInfo.getHeader());
  664.                             infoException.setMissingInfoFooter(asMissingInfo.getFooter());
  665.                             infoException.setMissingInfoDefault(asMissingInfo.getDefault());
  666.                         }
  667.                         
  668.                         if(!throwException && updateInfo){
  669.                             // Se non sono state lanciate eccezioni a questo punto posso usare le informazioni salvate di information missing per riempire
  670.                             // le informazioni mancanti negli altri archivi, altrimenti poi i metodi sottostanti lanceranno le relative informazioni
  671.                             // di information missing
  672.                             IDAccordo importInformationMissing_idAccordo = null;
  673.                             if(importInformationMissing!=null){
  674.                                 importInformationMissing_idAccordo = importInformationMissing.getIdAccordoServizioParteComune();
  675.                             }
  676.                             ImporterInformationMissingSetter.setInformationMissingAccordoServizioComposto(this.archive, asMissingInfo, 
  677.                                     importInformationMissing_idAccordo);
  678.                         }
  679.                         else{
  680.                             break;
  681.                         }
  682.                     }           
  683.                 }
  684.                 
  685.                 // -------- fruitori --------------
  686.                 
  687.                 if(!throwException && archiveInformationMissing.sizeFruitoreList()>0){
  688.                     for (int i = 0; i < archiveInformationMissing.sizeFruitoreList(); i++) {
  689.                         org.openspcoop2.protocol.information_missing.Fruitore fruitoreMissingInfo = 
  690.                                 archiveInformationMissing.getFruitore(i);
  691.                         
  692.                         if(fruitoreMissingInfo.getConditions()!=null) {
  693.                             if(checkConditions(fruitoreMissingInfo.getConditions(),requisitiInput)==false) {
  694.                                 continue;
  695.                             }
  696.                         }
  697.                         
  698.                         // *** object id ***
  699.                         
  700.                         importInformationMissing = null;
  701.                         objectId = "[[InformationMissingFruitore-"+indexInputPage+"-"+i+"]]"; 
  702.                         objectIdDescription = fruitoreMissingInfo.getDescrizione(); 
  703.                         if(this.importInformationMissingCollection!=null){
  704.                             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  705.                         }
  706.                         
  707.                         // *** campi da verificare ***
  708.                         boolean updateInfo = false;
  709.                         switch (fruitoreMissingInfo.getTipo()) {
  710.                         case CONNETTORE:
  711.                             if(delete==false) {
  712.                                 if(importInformationMissing!=null && importInformationMissing.getConnettore()!=null){
  713.                                     updateInfo = true;
  714.                                 }
  715.                                 else{
  716.                                     infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  717.                                     infoException.setMissingInfoConnettore(true);
  718.                                     throwException = true;
  719.                                 }
  720.                             }
  721.                             break;
  722.                         case STATO_ARCHIVIO:
  723.                             if(delete==false) {
  724.                                 updateInfo = true;
  725.                             }
  726.                             break;
  727.                         }
  728.                         if(infoException!=null) {
  729.                             infoException.setMissingInfoProtocollo(fruitoreMissingInfo.getProtocollo());
  730.                             infoException.setMissingInfoHeader(fruitoreMissingInfo.getHeader());
  731.                             infoException.setMissingInfoFooter(fruitoreMissingInfo.getFooter());
  732.                             infoException.setMissingInfoDefault(fruitoreMissingInfo.getDefault());
  733.                         }
  734.                         
  735.                         if(!throwException && updateInfo){
  736.                             // Se non sono state lanciate eccezioni a questo punto posso usare le informazioni salvate di information missing per riempire
  737.                             // le informazioni mancanti negli altri archivi, altrimenti poi i metodi sottostanti lanceranno le relative informazioni
  738.                             // di information missing
  739.                             Connettore importInformationMissing_connettore = null;
  740.                             if(importInformationMissing!=null){
  741.                                 importInformationMissing_connettore = importInformationMissing.getConnettore();
  742.                             }
  743.                             ImporterInformationMissingSetter.setInformationMissingFruitore(this.archive, fruitoreMissingInfo,
  744.                                     importInformationMissing_connettore);
  745.                         }
  746.                         else{
  747.                             break;
  748.                         }
  749.                     }           
  750.                 }
  751.                 
  752.                 // -------- porte delegate --------------
  753.                 
  754.                 if(!throwException && archiveInformationMissing.sizePortaDelegataList()>0){
  755.                     for (int i = 0; i < archiveInformationMissing.sizePortaDelegataList(); i++) {
  756.                         org.openspcoop2.protocol.information_missing.PortaDelegata portaMissingInfo = 
  757.                                 archiveInformationMissing.getPortaDelegata(i);
  758.                         
  759.                         if(portaMissingInfo.getConditions()!=null) {
  760.                             if(checkConditions(portaMissingInfo.getConditions(),requisitiInput)==false) {
  761.                                 continue;
  762.                             }
  763.                         }
  764.                         
  765.                         // *** object id ***
  766.                         
  767.                         importInformationMissing = null;
  768.                         objectId = "[[InformationMissingPortaDelegata-"+indexInputPage+"-"+i+"]]"; 
  769.                         objectIdDescription = portaMissingInfo.getDescrizione();    
  770.                         if(this.importInformationMissingCollection!=null){
  771.                             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  772.                         }
  773.                         
  774.                         // *** campi da verificare ***
  775.                         boolean updateInfo = false;
  776.                         switch (portaMissingInfo.getTipo()) {
  777.                         case STATO:
  778.                             if(delete==false) {
  779.                                 updateInfo = true;
  780.                             }
  781.                             break;
  782.                         }
  783.                         if(infoException!=null) {
  784.                             infoException.setMissingInfoProtocollo(portaMissingInfo.getProtocollo());
  785.                             infoException.setMissingInfoHeader(portaMissingInfo.getHeader());
  786.                             infoException.setMissingInfoFooter(portaMissingInfo.getFooter());
  787.                             infoException.setMissingInfoDefault(portaMissingInfo.getDefault());
  788.                         }
  789.                         
  790.                         if(!throwException && updateInfo){
  791.                             // Se non sono state lanciate eccezioni a questo punto posso usare le informazioni salvate di information missing per riempire
  792.                             // le informazioni mancanti negli altri archivi, altrimenti poi i metodi sottostanti lanceranno le relative informazioni
  793.                             // di information missing
  794.                             ImporterInformationMissingSetter.setInformationMissingPortaDelegata(this.archive, portaMissingInfo);
  795.                         }
  796.                         else{
  797.                             break;
  798.                         }
  799.                     }           
  800.                 }
  801.                 
  802.                 // -------- porte applicative --------------
  803.                 
  804.                 if(!throwException && archiveInformationMissing.sizePortaApplicativaList()>0){
  805.                     for (int i = 0; i < archiveInformationMissing.sizePortaApplicativaList(); i++) {
  806.                         org.openspcoop2.protocol.information_missing.PortaApplicativa portaMissingInfo = 
  807.                                 archiveInformationMissing.getPortaApplicativa(i);
  808.                         
  809.                         if(portaMissingInfo.getConditions()!=null) {
  810.                             if(checkConditions(portaMissingInfo.getConditions(),requisitiInput)==false) {
  811.                                 continue;
  812.                             }
  813.                         }
  814.                         
  815.                         // *** object id ***
  816.                         
  817.                         importInformationMissing = null;
  818.                         objectId = "[[InformationMissingPortaApplicativa-"+indexInputPage+"-"+i+"]]"; 
  819.                         objectIdDescription = portaMissingInfo.getDescrizione();    
  820.                         if(this.importInformationMissingCollection!=null){
  821.                             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  822.                         }
  823.                         
  824.                         // *** campi da verificare ***
  825.                         boolean updateInfo = false;
  826.                         switch (portaMissingInfo.getTipo()) {
  827.                         case STATO:
  828.                             if(delete==false) {
  829.                                 updateInfo = true;
  830.                             }
  831.                             break;
  832.                         }
  833.                         if(infoException!=null) {
  834.                             infoException.setMissingInfoProtocollo(portaMissingInfo.getProtocollo());
  835.                             infoException.setMissingInfoHeader(portaMissingInfo.getHeader());
  836.                             infoException.setMissingInfoFooter(portaMissingInfo.getFooter());
  837.                             infoException.setMissingInfoDefault(portaMissingInfo.getDefault());
  838.                         }
  839.                         
  840.                         if(!throwException && updateInfo){
  841.                             // Se non sono state lanciate eccezioni a questo punto posso usare le informazioni salvate di information missing per riempire
  842.                             // le informazioni mancanti negli altri archivi, altrimenti poi i metodi sottostanti lanceranno le relative informazioni
  843.                             // di information missing
  844.                             ImporterInformationMissingSetter.setInformationMissingPortaApplicativa(this.archive, portaMissingInfo);
  845.                         }
  846.                         else{
  847.                             break;
  848.                         }
  849.                     }           
  850.                 }
  851.             
  852.             }
  853.                 
  854.             // se e' stata rilevata una mancanza sollevo eccezione
  855.             if(throwException){
  856.                 throw infoException;
  857.             }
  858.                         
  859.         }catch(ImportInformationMissingException e){
  860.             throw e;
  861.         }catch(Exception e){
  862.             throw new Exception(objectIdDescription+" validazione fallita: "+e.getMessage(),e);
  863.         }
  864.     }
  865.     
  866.     public static boolean checkConditions(ConditionsType conditions, HashMap<String, String> map) {
  867.         if(conditions==null) {
  868.             return false;
  869.         }
  870.         boolean result = _checkConditions(conditions, map);
  871.         if(conditions!=null && conditions.isNot()) {
  872.             return !result;
  873.         }
  874.         else {
  875.             return result;
  876.         }
  877.     }
  878.     private static boolean _checkConditions(ConditionsType conditions, HashMap<String, String> map) {
  879.         boolean and = conditions!=null && conditions.isAnd();
  880.         if(conditions!=null && conditions.sizeProprietaList()>0) {
  881.             for (ConditionType cType : conditions.getProprietaList()) {
  882.                 if(map==null || map.isEmpty() || map.containsKey(cType.getNome())==false) {
  883.                     if(cType.isNot()==false && and) {
  884.                         return false;
  885.                     }
  886.                 }
  887.                 String value = null;
  888.                 if(map!=null){
  889.                     value = map.get(cType.getNome());
  890.                 }
  891.                 
  892.                 if(value==null) {
  893.                     if(and) {
  894.                         return false;
  895.                     }
  896.                     else {
  897.                         continue; // vedo il prossimo, al massimo in fondo torno false se non sono and
  898.                     }
  899.                 }
  900.                 
  901.                 if(cType.isNot()) {
  902.                     if(cType.getValore().equals(value)) {
  903.                         if(and) {
  904.                             return false;
  905.                         }
  906.                     }
  907.                     else {
  908.                         if(and==false) {
  909.                             return true;
  910.                         }
  911.                     }
  912.                 }
  913.                 else {
  914.                     if(cType.getValore().equals(value)==false) {
  915.                         if(and) {
  916.                             return false;
  917.                         }
  918.                     }
  919.                     else {
  920.                         if(and==false) {
  921.                             return true;
  922.                         }
  923.                     }
  924.                 }
  925.                 
  926.             }
  927.         }
  928.         if(and) {
  929.             return true;
  930.         }
  931.         else {
  932.             return false;
  933.         }
  934.     }
  935.     
  936.     
  937.     public void validateAndFillServizioApplicativo(ArchiveServizioApplicativo archiveServizioApplicativo) throws Exception{
  938.         
  939.         // *** object id ***
  940.         
  941.         ServizioApplicativo sa = archiveServizioApplicativo.getServizioApplicativo();
  942.         String uri = sa.getNome();
  943.         if(sa.getTipoSoggettoProprietario()!=null && sa.getNomeSoggettoProprietario()!=null){
  944.             uri = uri +":"+sa.getTipoSoggettoProprietario()+"/"+sa.getNomeSoggettoProprietario();
  945.         }
  946.         String objectId = "[[SA]]"+uri; 
  947.         String objectIdDescription = "Servizio Applicativo ["+uri+"]";      
  948.         ImportInformationMissing importInformationMissing = null;
  949.         if(this.importInformationMissingCollection!=null){
  950.             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  951.         }
  952.         
  953.         try{
  954.             
  955.             // *** campi da verificare ***
  956.             
  957.             String tipoSoggettoProprietario = sa.getTipoSoggettoProprietario();
  958.             String nomeSoggettoProprietario = sa.getNomeSoggettoProprietario();
  959.             if(tipoSoggettoProprietario==null || nomeSoggettoProprietario==null){
  960.                 
  961.                 // provo ad utilizzare le informazioni eventualmente presenti nell'oggetto importInformationMissing
  962.                 // se non sono presenti nemmeno in tale oggetto, sollevo eccezione
  963.                 ImportInformationMissingException infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  964.                 boolean throwException = false;
  965.                 
  966.                 // soggetto
  967.                 if(tipoSoggettoProprietario==null || nomeSoggettoProprietario==null){
  968.                     if(importInformationMissing!=null && importInformationMissing.getSoggetto()!=null){
  969.                         if(!this.registryReader.existsSoggetto(importInformationMissing.getSoggetto())){
  970.                             // verifico che non esista nell'archivio che sto importanto
  971.                             boolean found = false;
  972.                             if(this.archive.getSoggetti()!=null && this.archive.getSoggetti().size()>0){
  973.                                 for (int i = 0; i < this.archive.getSoggetti().size(); i++) {
  974.                                     ArchiveSoggetto archiveSoggetto = this.archive.getSoggetti().get(i);
  975.                                     if(archiveSoggetto.getIdSoggetto().equals(importInformationMissing.getSoggetto())){
  976.                                         found = true;
  977.                                         break;
  978.                                     }
  979.                                 }
  980.                             }
  981.                             if(!found){
  982.                                 throw new ProtocolException("Il Soggetto "+importInformationMissing.getSoggetto().toString()+" non esiste (indicato in ImportInformationMissing parameter??)");
  983.                             }
  984.                         }
  985.                         sa.setTipoSoggettoProprietario(importInformationMissing.getSoggetto().getTipo());
  986.                         sa.setNomeSoggettoProprietario(importInformationMissing.getSoggetto().getNome());
  987.                     }else{
  988.                         infoException.setMissingInfoSoggetto(true);
  989.                         throwException = true;
  990.                     }
  991.                 }
  992.                                 
  993.                 // se e' stata rilevata una mancanza sollevo eccezione
  994.                 if(throwException)
  995.                     throw infoException;
  996.             }
  997.             
  998.             
  999.             // *** Verifica documenti presenti all'interno dell'archivio ***

  1001.             // non esistono
  1002.                         
  1003.         }catch(ImportInformationMissingException e){
  1004.             throw e;
  1005.         }catch(Exception e){
  1006.             throw new Exception(objectIdDescription+" validazione fallita: "+e.getMessage(),e);
  1007.         }
  1008.     }
  1009.     
  1010.     
  1011.     
  1012.     public void validateAndFillPortaDelegata(ArchivePortaDelegata archivePortaDelegata) throws Exception{
  1013.         
  1014.         // *** object id ***
  1015.         
  1016.         PortaDelegata pd = archivePortaDelegata.getPortaDelegata();
  1017.         String uri = pd.getNome();
  1018.         if(pd.getTipoSoggettoProprietario()!=null && pd.getNomeSoggettoProprietario()!=null){
  1019.             uri = uri +":"+pd.getTipoSoggettoProprietario()+"/"+pd.getNomeSoggettoProprietario();
  1020.         }
  1021.         String objectId = "[[PD]]"+uri; 
  1022.         String objectIdDescription = "PortaDelegata ["+uri+"]";     
  1023.         ImportInformationMissing importInformationMissing = null;
  1024.         if(this.importInformationMissingCollection!=null){
  1025.             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  1026.         }
  1027.         
  1028.         try{
  1029.             
  1030.             // *** campi da verificare ***
  1031.             
  1032.             String tipoSoggettoProprietario = pd.getTipoSoggettoProprietario();
  1033.             String nomeSoggettoProprietario = pd.getNomeSoggettoProprietario();
  1034.             if(tipoSoggettoProprietario==null || nomeSoggettoProprietario==null){
  1035.                 
  1036.                 // provo ad utilizzare le informazioni eventualmente presenti nell'oggetto importInformationMissing
  1037.                 // se non sono presenti nemmeno in tale oggetto, sollevo eccezione
  1038.                 ImportInformationMissingException infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  1039.                 boolean throwException = false;
  1040.                 
  1041.                 // soggetto
  1042.                 if(tipoSoggettoProprietario==null || nomeSoggettoProprietario==null){
  1043.                     if(importInformationMissing!=null && importInformationMissing.getSoggetto()!=null){
  1044.                         if(!this.registryReader.existsSoggetto(importInformationMissing.getSoggetto())){
  1045.                             // verifico che non esista nell'archivio che sto importanto
  1046.                             boolean found = false;
  1047.                             if(this.archive.getSoggetti()!=null && this.archive.getSoggetti().size()>0){
  1048.                                 for (int i = 0; i < this.archive.getSoggetti().size(); i++) {
  1049.                                     ArchiveSoggetto archiveSoggetto = this.archive.getSoggetti().get(i);
  1050.                                     if(archiveSoggetto.getIdSoggetto().equals(importInformationMissing.getSoggetto())){
  1051.                                         found = true;
  1052.                                         break;
  1053.                                     }
  1054.                                 }
  1055.                             }
  1056.                             if(!found){
  1057.                                 throw new ProtocolException("Il Soggetto "+importInformationMissing.getSoggetto().toString()+" non esiste (indicato in ImportInformationMissing parameter??)");
  1058.                             }
  1059.                         }
  1060.                         pd.setTipoSoggettoProprietario(importInformationMissing.getSoggetto().getTipo());
  1061.                         pd.setNomeSoggettoProprietario(importInformationMissing.getSoggetto().getNome());
  1062.                     }else{
  1063.                         infoException.setMissingInfoSoggetto(true);
  1064.                         throwException = true;
  1065.                     }
  1066.                 }
  1067.                                 
  1068.                 // se e' stata rilevata una mancanza sollevo eccezione
  1069.                 if(throwException)
  1070.                     throw infoException;
  1071.             }
  1072.             
  1073.             
  1074.             // *** Verifica documenti presenti all'interno dell'archivio ***

  1076.             // non esistono
  1077.                         
  1078.         }catch(ImportInformationMissingException e){
  1079.             throw e;
  1080.         }catch(Exception e){
  1081.             throw new Exception(objectIdDescription+" validazione fallita: "+e.getMessage(),e);
  1082.         }
  1083.     }
  1084.     
  1085.     
  1086.     
  1087.     
  1088.     public void validateAndFillPortaApplicativa(ArchivePortaApplicativa archivePortaApplicativa) throws Exception{
  1089.         
  1090.         // *** object id ***
  1091.         
  1092.         PortaApplicativa pa = archivePortaApplicativa.getPortaApplicativa();
  1093.         String uri = pa.getNome();
  1094.         if(pa.getTipoSoggettoProprietario()!=null && pa.getNomeSoggettoProprietario()!=null){
  1095.             uri = uri +":"+pa.getTipoSoggettoProprietario()+"/"+pa.getNomeSoggettoProprietario();
  1096.         }
  1097.         String objectId = "[[PD]]"+uri; 
  1098.         String objectIdDescription = "PortaApplicativa ["+uri+"]";      
  1099.         ImportInformationMissing importInformationMissing = null;
  1100.         if(this.importInformationMissingCollection!=null){
  1101.             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  1102.         }
  1103.         
  1104.         try{
  1105.             
  1106.             // *** campi da verificare ***
  1107.             
  1108.             String tipoSoggettoProprietario = pa.getTipoSoggettoProprietario();
  1109.             String nomeSoggettoProprietario = pa.getNomeSoggettoProprietario();
  1110.             if(tipoSoggettoProprietario==null || nomeSoggettoProprietario==null){
  1111.                 
  1112.                 // provo ad utilizzare le informazioni eventualmente presenti nell'oggetto importInformationMissing
  1113.                 // se non sono presenti nemmeno in tale oggetto, sollevo eccezione
  1114.                 ImportInformationMissingException infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  1115.                 boolean throwException = false;
  1116.                 
  1117.                 // soggetto
  1118.                 if(tipoSoggettoProprietario==null || nomeSoggettoProprietario==null){
  1119.                     if(importInformationMissing!=null && importInformationMissing.getSoggetto()!=null){
  1120.                         if(!this.registryReader.existsSoggetto(importInformationMissing.getSoggetto())){
  1121.                             // verifico che non esista nell'archivio che sto importanto
  1122.                             boolean found = false;
  1123.                             if(this.archive.getSoggetti()!=null && this.archive.getSoggetti().size()>0){
  1124.                                 for (int i = 0; i < this.archive.getSoggetti().size(); i++) {
  1125.                                     ArchiveSoggetto archiveSoggetto = this.archive.getSoggetti().get(i);
  1126.                                     if(archiveSoggetto.getIdSoggetto().equals(importInformationMissing.getSoggetto())){
  1127.                                         found = true;
  1128.                                         break;
  1129.                                     }
  1130.                                 }
  1131.                             }
  1132.                             if(!found){
  1133.                                 throw new ProtocolException("Il Soggetto "+importInformationMissing.getSoggetto().toString()+" non esiste (indicato in ImportInformationMissing parameter??)");
  1134.                             }
  1135.                         }
  1136.                         pa.setTipoSoggettoProprietario(importInformationMissing.getSoggetto().getTipo());
  1137.                         pa.setNomeSoggettoProprietario(importInformationMissing.getSoggetto().getNome());
  1138.                     }else{
  1139.                         infoException.setMissingInfoSoggetto(true);
  1140.                         throwException = true;
  1141.                     }
  1142.                 }
  1143.                                 
  1144.                 // se e' stata rilevata una mancanza sollevo eccezione
  1145.                 if(throwException)
  1146.                     throw infoException;
  1147.             }
  1148.             
  1149.             
  1150.             // *** Verifica documenti presenti all'interno dell'archivio ***

  1152.             // non esistono
  1153.                         
  1154.         }catch(ImportInformationMissingException e){
  1155.             throw e;
  1156.         }catch(Exception e){
  1157.             throw new Exception(objectIdDescription+" validazione fallita: "+e.getMessage(),e);
  1158.         }
  1159.     }
  1160.     
  1161.     
  1162.     
  1163.     public void validateAndFillAccordoCooperazione(ArchiveAccordoCooperazione archiveAccordoCooperazione) throws Exception{
  1164.         
  1165.         // *** object id ***
  1166.         
  1167.         AccordoCooperazione ac = archiveAccordoCooperazione.getAccordoCooperazione();
  1168.         String uri = this.idAccordoCooperazioneFactory.getUriFromAccordo(ac);
  1169.         String objectId = "[[AC]]"+uri; 
  1170.         String objectIdDescription = "Accordo di Cooperazione ["+uri+"]";       
  1171.         ImportInformationMissing importInformationMissing = null;
  1172.         if(this.importInformationMissingCollection!=null){
  1173.             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  1174.         }
  1175.         
  1176.         try{
  1177.             
  1178.             // *** campi da verificare ***
  1179.             
  1180.             IdSoggetto acSoggettoReferente = ac.getSoggettoReferente();
  1181.             Integer versione = ac.getVersione();
  1182.             if( (acSoggettoReferente==null || acSoggettoReferente.getTipo()==null || acSoggettoReferente.getNome()==null) 
  1183.                     || 
  1184.                     versione==null){
  1185.                 
  1186.                 // provo ad utilizzare le informazioni eventualmente presenti nell'oggetto importInformationMissing
  1187.                 // se non sono presenti nemmeno in tale oggetto, sollevo eccezione
  1188.                 ImportInformationMissingException infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  1189.                 boolean throwException = false;
  1190.                 
  1191.                 // soggetto
  1192.                 if(acSoggettoReferente==null || acSoggettoReferente.getTipo()==null || acSoggettoReferente.getNome()==null){
  1193.                     if(importInformationMissing!=null && importInformationMissing.getSoggetto()!=null){
  1194.                         if(!this.registryReader.existsSoggetto(importInformationMissing.getSoggetto())){
  1195.                             // verifico che non esista nell'archivio che sto importanto
  1196.                             boolean found = false;
  1197.                             if(this.archive.getSoggetti()!=null && this.archive.getSoggetti().size()>0){
  1198.                                 for (int i = 0; i < this.archive.getSoggetti().size(); i++) {
  1199.                                     ArchiveSoggetto archiveSoggetto = this.archive.getSoggetti().get(i);
  1200.                                     if(archiveSoggetto.getIdSoggetto().equals(importInformationMissing.getSoggetto())){
  1201.                                         found = true;
  1202.                                         break;
  1203.                                     }
  1204.                                 }
  1205.                             }
  1206.                             if(!found){
  1207.                                 throw new ProtocolException("Il Soggetto "+importInformationMissing.getSoggetto().toString()+" non esiste (indicato in ImportInformationMissing parameter??)");
  1208.                             }
  1209.                         }
  1210.                         IdSoggetto acSoggettoReferenteNew = new IdSoggetto();
  1211.                         acSoggettoReferenteNew.setTipo(importInformationMissing.getSoggetto().getTipo());
  1212.                         acSoggettoReferenteNew.setNome(importInformationMissing.getSoggetto().getNome());
  1213.                         ac.setSoggettoReferente(acSoggettoReferenteNew);
  1214.                     }else{
  1215.                         infoException.setMissingInfoSoggetto(true);
  1216.                         throwException = true;
  1217.                     }
  1218.                 }
  1219.                 
  1220.                 // versione
  1221.                 if(versione==null){
  1222.                     if(importInformationMissing!=null && importInformationMissing.getVersione()!=null){
  1223.                         ac.setVersione(importInformationMissing.getVersione());
  1224.                     }else{
  1225.                         infoException.setMissingInfoVersione(true);
  1226.                         throwException = true;
  1227.                     }
  1228.                 }
  1229.                                 
  1230.                 // se e' stata rilevata una mancanza sollevo eccezione
  1231.                 if(throwException)
  1232.                     throw infoException;
  1233.             }
  1234.             
  1235.             
  1236.             // *** Verifica documenti presenti all'interno dell'archivio ***
  1237.             
  1238.             if(this.validateDocuments){
  1239.                 
  1240.                 ValidazioneResult result = this.validatoreDocumenti.validaDocumenti(ac);
  1241.                 if(result.isEsito()==false){
  1242.                     if(result.getException()!=null)
  1243.                         throw new Exception(result.getMessaggioErrore(),result.getException());
  1244.                     else
  1245.                         throw new Exception(result.getMessaggioErrore());
  1246.                 }
  1247.                 
  1248.             }
  1249.             
  1250.                         
  1251.         }catch(ImportInformationMissingException e){
  1252.             throw e;
  1253.         }catch(Exception e){
  1254.             throw new Exception(objectIdDescription+" validazione fallita: "+e.getMessage(),e);
  1255.         }
  1256.     }
  1257.     
  1258.     public void validateAndFillAccordoServizioParteComune(ArchiveAccordoServizioParteComune archiveAspc,boolean checkCorrelazioneAsincrona) throws Exception{
  1259.         this.validateAndFillAccordoServizioEngine(archiveAspc.getAccordoServizioParteComune(),checkCorrelazioneAsincrona);
  1260.     }
  1261.     public void validateAndFillAccordoServizioParteComune(ArchiveAccordoServizioComposto archiveAsc,boolean checkCorrelazioneAsincrona) throws Exception{
  1262.         this.validateAndFillAccordoServizioEngine(archiveAsc.getAccordoServizioParteComune(),checkCorrelazioneAsincrona);
  1263.     }
  1264.     private void validateAndFillAccordoServizioEngine(AccordoServizioParteComune aspc,boolean checkCorrelazioneAsincrona) throws Exception{
  1265.         
  1266.         // *** object id ***
  1267.         
  1268.         String uri = this.idAccordoFactory.getUriFromAccordo(aspc);
  1269.         String tipoAccordo = "[[ASPC]]";
  1270.         if(aspc.getServizioComposto()!=null){
  1271.             tipoAccordo = "[[ASC]]";
  1272.         }
  1273.         String objectId = tipoAccordo+uri; 
  1274.         String objectIdDescription = "Accordo di Servizio Parte Comune ["+uri+"]";
  1275.         if(aspc.getServizioComposto()!=null){
  1276.             objectIdDescription = "Accordo di Servizio Composto ["+uri+"]";
  1277.             if(aspc.getServizioComposto().getAccordoCooperazione()!=null && !"".equals(aspc.getServizioComposto().getAccordoCooperazione().trim())){
  1278.                 objectIdDescription = objectIdDescription + " (rifAccordo: "+aspc.getServizioComposto().getAccordoCooperazione()+")";
  1279.             }
  1280.         }
  1281.         ImportInformationMissing importInformationMissing = null;
  1282.         if(this.importInformationMissingCollection!=null){
  1283.             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  1284.         }
  1285.         
  1286.         
  1287.         try{
  1288.         
  1289.             // *** campi da verificare ***
  1290.             
  1291.             IdSoggetto aspcSoggettoReferente = aspc.getSoggettoReferente();
  1292.             Integer versione = aspc.getVersione();
  1293.             boolean informazioniProfiloServiziPresenti = this.isInformazioniProfiloServiziPresenti(aspc,checkCorrelazioneAsincrona);
  1294.             String uriAccordoCooperazione = null;
  1295.             if(aspc.getServizioComposto()!=null){
  1296.                 if(aspc.getServizioComposto().getAccordoCooperazione()!=null && !"".equals(aspc.getServizioComposto().getAccordoCooperazione().trim())){
  1297.                     uriAccordoCooperazione = aspc.getServizioComposto().getAccordoCooperazione();
  1298.                 }
  1299.             }
  1300.                 
  1301.             if( (aspcSoggettoReferente==null || aspcSoggettoReferente.getTipo()==null || aspcSoggettoReferente.getNome()==null) 
  1302.                     || 
  1303.                     versione==null 
  1304.                     || 
  1305.                     !informazioniProfiloServiziPresenti
  1306.                     ||
  1307.                     ( (aspc.getServizioComposto()!=null) && (uriAccordoCooperazione==null) )
  1308.                 ){
  1309.                 
  1310.                 // provo ad utilizzare le informazioni eventualmente presenti nell'oggetto importInformationMissing
  1311.                 // se non sono presenti nemmeno in tale oggetto, sollevo eccezione
  1312.                 ImportInformationMissingException infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  1313.                 boolean throwException = false;
  1314.                 
  1315.                 // soggetto
  1316.                 if(aspcSoggettoReferente==null || aspcSoggettoReferente.getTipo()==null || aspcSoggettoReferente.getNome()==null){
  1317.                     if(importInformationMissing!=null && importInformationMissing.getSoggetto()!=null){
  1318.                         if(!this.registryReader.existsSoggetto(importInformationMissing.getSoggetto())){
  1319.                             // verifico che non esista nell'archivio che sto importanto
  1320.                             boolean found = false;
  1321.                             if(this.archive.getSoggetti()!=null && this.archive.getSoggetti().size()>0){
  1322.                                 for (int i = 0; i < this.archive.getSoggetti().size(); i++) {
  1323.                                     ArchiveSoggetto archiveSoggetto = this.archive.getSoggetti().get(i);
  1324.                                     if(archiveSoggetto.getIdSoggetto().equals(importInformationMissing.getSoggetto())){
  1325.                                         found = true;
  1326.                                         break;
  1327.                                     }
  1328.                                 }
  1329.                             }
  1330.                             if(!found){
  1331.                                 throw new ProtocolException("Il Soggetto "+importInformationMissing.getSoggetto().toString()+" non esiste (indicato in ImportInformationMissing parameter??)");
  1332.                             }
  1333.                         }
  1334.                         IdSoggetto aspcSoggettoReferenteNew = new IdSoggetto();
  1335.                         aspcSoggettoReferenteNew.setTipo(importInformationMissing.getSoggetto().getTipo());
  1336.                         aspcSoggettoReferenteNew.setNome(importInformationMissing.getSoggetto().getNome());
  1337.                         aspc.setSoggettoReferente(aspcSoggettoReferenteNew);
  1338.                     }else{
  1339.                         infoException.setMissingInfoSoggetto(true);
  1340.                         throwException = true;
  1341.                     }
  1342.                 }
  1343.                 
  1344.                 // versione
  1345.                 if(versione==null){
  1346.                     if(importInformationMissing!=null && importInformationMissing.getVersione()!=null){
  1347.                         aspc.setVersione(importInformationMissing.getVersione());
  1348.                     }else{
  1349.                         infoException.setMissingInfoVersione(true);
  1350.                         throwException = true;
  1351.                     }
  1352.                 }
  1353.                 
  1354.                 // info sui servizi
  1355.                 if(!informazioniProfiloServiziPresenti){
  1356.                     if(importInformationMissing!=null && importInformationMissing.sizePortTypeList()>0){
  1357.                         for(int i=0; i<importInformationMissing.sizePortTypeList(); i++){
  1358.                             aspc.addPortType(importInformationMissing.getPortType(i));
  1359.                         }
  1360.                     }
  1361.                     // ricalcolo se adesso tutte le informazioni sono valide
  1362.                     informazioniProfiloServiziPresenti = this.isInformazioniProfiloServiziPresenti(aspc,checkCorrelazioneAsincrona);
  1363.                     if(!informazioniProfiloServiziPresenti){
  1364.                         infoException.setMissingInfoProfiliServizi(true);
  1365.                         // elimino tanto verranno ricreati dall'interfaccia
  1366.                         while(aspc.sizePortTypeList()>0){
  1367.                             aspc.removePortType(0);
  1368.                         }
  1369.                         infoException.setObject(aspc);
  1370.                         infoException.setClassObject(aspc.getClass());
  1371.                         throwException = true;
  1372.                     }
  1373.                 }
  1374.                                 
  1375.                 // accordoCooperazione
  1376.                 if( (aspc.getServizioComposto()!=null) && (uriAccordoCooperazione==null) ){
  1377.                     if(importInformationMissing!=null && importInformationMissing.getIdAccordoCooperazione()!=null){
  1378.                         aspc.getServizioComposto().setAccordoCooperazione(this.idAccordoCooperazioneFactory.getUriFromIDAccordo(importInformationMissing.getIdAccordoCooperazione()));
  1379.                     }else{
  1380.                         infoException.setMissingInfoAccordoCooperazione(true);
  1381.                         throwException = true;
  1382.                     }
  1383.                 }
  1384.                                 
  1385.                 // se e' stata rilevata una mancanza sollevo eccezione
  1386.                 if(throwException)
  1387.                     throw infoException;
  1388.             }
  1389.             
  1390.             
  1391.             // *** Verifica documenti presenti all'interno del package ***
  1392.             
  1393.             if(this.validateDocuments){
  1394.                 
  1395.                 ValidazioneResult result = this.validatoreDocumenti.validaSpecificaInterfaccia(aspc);
  1396.                 if(result.isEsito()==false){
  1397.                     if(result.getException()!=null)
  1398.                         throw new Exception(result.getMessaggioErrore(),result.getException());
  1399.                     else
  1400.                         throw new Exception(result.getMessaggioErrore());
  1401.                 }
  1402.                 
  1403.                 result = this.validatoreDocumenti.validaSpecificaConversazione(aspc);
  1404.                 if(result.isEsito()==false){
  1405.                     if(result.getException()!=null)
  1406.                         throw new Exception(result.getMessaggioErrore(),result.getException());
  1407.                     else
  1408.                         throw new Exception(result.getMessaggioErrore());
  1409.                 }
  1410.                 
  1411.                 result = this.validatoreDocumenti.validaDocumenti(aspc);
  1412.                 if(result.isEsito()==false){
  1413.                     if(result.getException()!=null)
  1414.                         throw new Exception(result.getMessaggioErrore(),result.getException());
  1415.                     else
  1416.                         throw new Exception(result.getMessaggioErrore());
  1417.                 }
  1418.                 
  1419.             }
  1420.             
  1421.         }catch(ImportInformationMissingException e){
  1422.             throw e;
  1423.         }catch(Exception e){
  1424.             throw new Exception(objectIdDescription+" validazione fallita: "+e.getMessage(),e);
  1425.         }

  1427.     }
  1428.     
  1429.     private boolean  isInformazioniProfiloServiziPresenti(AccordoServizioParteComune aspc,boolean checkCorrelazioneAsincrona){
  1430.         if(aspc==null){
  1431.             return false;
  1432.         }
  1433.         
  1434.         if(aspc.getProfiloCollaborazione()==null && aspc.sizePortTypeList()<=0){
  1435.             return false;
  1436.         }
  1437.         
  1438.         if(aspc.sizePortTypeList()>0){
  1439.             for (int i = 0; i < aspc.sizePortTypeList(); i++) {
  1440.                 PortType pt = aspc.getPortType(i);
  1441.                 if(pt==null){
  1442.                     return false;
  1443.                 }
  1444.                 //String profiloCollaborazionePT = pt.getProfiloCollaborazione();
  1445.                 if(CostantiRegistroServizi.PROFILO_AZIONE_DEFAULT.equals(pt.getProfiloPT())){
  1446.                     // default
  1447.                     if(aspc.getProfiloCollaborazione()==null){
  1448.                         return false;
  1449.                     }
  1450.                     //profiloCollaborazionePT = aspc.getProfiloCollaborazione();
  1451.                 }
  1452.                 else{
  1453.                     // ridefinisci
  1454.                     if(pt.getProfiloCollaborazione()==null && aspc.getProfiloCollaborazione()==null){
  1455.                         return false;
  1456.                     }
  1457.                 }
  1458.                 for (int j = 0; j < pt.sizeAzioneList(); j++) {
  1459.                     Operation op = pt.getAzione(j);
  1460.                     //String profiloCollaborazioneAzione = null;
  1461.                     if(CostantiRegistroServizi.PROFILO_AZIONE_DEFAULT.equals(op.getProfAzione())){
  1462.                         // default
  1463.                         if(aspc.getProfiloCollaborazione()==null && pt.getProfiloCollaborazione()==null){
  1464.                             return false;
  1465.                         }
  1466.                         //profiloCollaborazioneAzione = profiloCollaborazionePT;
  1467.                     }
  1468.                     else{
  1469.                         // ridefinisci
  1470.                         if(op.getProfiloCollaborazione()==null && pt.getProfiloCollaborazione()==null && aspc.getProfiloCollaborazione()==null){
  1471.                             return false;
  1472.                         }
  1473.                         //profiloCollaborazioneAzione = op.getProfiloCollaborazione();
  1474.                     }
  1475.                     
  1476.                     // check correlazione asincrona
  1477.                     // Si creano dipendenze circolari.
  1478.                     // Inoltre non e' possibile importare un package, se prima non e' stato importato quello del correlato.
  1479. //                  if(checkCorrelazioneAsincrona){
  1480. //                      if(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO.equals(profiloCollaborazioneAzione) ||
  1481. //                              CostantiRegistroServizi.ASINCRONO_SIMMETRICO.equals(profiloCollaborazioneAzione)){
  1482. //                          if(op.getCorrelata()==null){
  1483. //                              // search correlazione
  1484. //                              if(existsCorrelazioneAsincrona(aspc.getPortTypeList(), pt.getNome(), op.getNome())==false){
  1485. //                                  return false;
  1486. //                              }
  1487. //                          }
  1488. //                      }
  1489. //                  }
  1490.                 }
  1491.             }
  1492.         }
  1493.         else{
  1494.             
  1495.         }
  1496.         
  1497.         return true;
  1498.     }
  1499.     
  1500. //  private boolean existsCorrelazioneAsincrona(List<PortType> listPortTypes, String ptName, String opName){
  1501. //      for (PortType portType : listPortTypes) {
  1502. //          for (Operation operation : portType.getAzioneList()) {
  1503. //              if(operation.getNome().equals(opName) && portType.getNome().equals(ptName)){
  1504. //                  continue;
  1505. //              }
  1506. //              if(operation.getCorrelata()!=null && opName.equals(operation.getCorrelata())){
  1507. //                  if(operation.getCorrelataServizio()==null && portType.getNome().equals(ptName)){
  1508. //                      return true; // correlazione verso altra azione dello stesso port type indicato come parametro;
  1509. //                  }
  1510. //                  if(operation.getCorrelataServizio()!=null && operation.getCorrelataServizio().equals(ptName)){
  1511. //                      return true; // correlazione verso il servizio e l'azione indicata come parametro;
  1512. //                  }
  1513. //              }
  1514. //          }
  1515. //      }
  1516. //      return false;
  1517. //  }
  1518.     
  1519.     public void validateAndFillAccordoServizioParteSpecifica(ArchiveAccordoServizioParteSpecifica archiveAsps,
  1520.             Map<String, IDSoggetto> mapIdSoggettoDefault,
  1521.             Map<String, Boolean> mapAPIconReferente) throws Exception{
  1522.         
  1523.         // *** object id ***
  1524.         AccordoServizioParteSpecifica asps = archiveAsps.getAccordoServizioParteSpecifica();
  1525.         String uri = null;
  1526.         if(asps.getTipoSoggettoErogatore()==null || asps.getNomeSoggettoErogatore()==null || asps.getVersione()==null) {
  1527.             uri = asps.getTipo()+"/"+asps.getNome();
  1528.         }
  1529.         else {
  1530.             uri = this.idServizioFactory.getUriFromAccordo(asps);
  1531.         }
  1532.         String objectId = "[[ASPS]]"+uri; 
  1533.         String objectIdDescription = "Accordo di Servizio Parte Specifica ["+uri+"]";
  1534.         if(asps.getAccordoServizioParteComune()!=null && !"".equals(asps.getAccordoServizioParteComune().trim())){
  1535.             objectIdDescription = objectIdDescription +" (rifParteComune: "+asps.getAccordoServizioParteComune()+")";
  1536.         }
  1537.         ImportInformationMissing importInformationMissing = null;
  1538.         if(this.importInformationMissingCollection!=null){
  1539.             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  1540.         }
  1541.         
  1542.         
  1543.         try{            
  1544.             // *** Verifica riferimento Parte Comune ***
  1545.             AccordoServizioParteComune aspc = null;
  1546.             if(asps.getAccordoServizioParteComune()!=null && !"".equals(asps.getAccordoServizioParteComune().trim())){
  1547.                 String uriAPC = asps.getAccordoServizioParteComune();
  1548.                 try{
  1549.                     
  1550.                     // Il riferimento potrebbe contenere un nome dinamico rispetto all'erogatore
  1551.                     if(uriAPC!=null) {
  1552.                         uriAPC = ImporterInformationMissingSetter.replaceSoggettoProprietarioOrDefault(this.registryReader, uriAPC, asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore());
  1553.                         uriAPC = ImporterInformationMissingSetter.replaceSoggettoErogatore(uriAPC, asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore());
  1554.                     }
  1555.                     
  1556.                     IDAccordo idAccordo = this.idAccordoFactory.getIDAccordoFromUri(uriAPC);
  1557.                     
  1558.                     // Gestione SoggettoReferente per verifica riferimento Parte Comune ***
  1559.                     IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(asps.getTipoSoggettoErogatore());
  1560.                     boolean APIconReferente = mapAPIconReferente.get(protocolFactory.getProtocol());
  1561.                     if(!APIconReferente) {
  1562.                         IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol()); 
  1563.                         if(!idAccordo.getSoggettoReferente().equals(soggettoDefaultProtocollo)) {
  1564.                             idAccordo.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  1565.                             idAccordo.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  1566.                         }
  1567.                     }
  1568.                     
  1569.                     // Verifica
  1570.                     aspc = this.registryReader.getAccordoServizioParteComune(idAccordo);
  1571.                     if(aspc==null){
  1572.                         throw new Exception("getAccordoServizioParteComune return null"); 
  1573.                     }
  1574.                 //}catch(RegistryNotFound notFound){
  1575.                 }catch(Exception notFound){ // Se non esiste il soggetto, il metodo sopra ritorna null, poichè il driver non ritorna notFound. Questo succede se il soggetto è nell'archivio
  1576.                     // verifico che non esista nell'archivio che sto importanto
  1577.                     boolean found = false;
  1578.                     if(this.archive.getAccordiServizioParteComune()!=null && this.archive.getAccordiServizioParteComune().size()>0){
  1579.                         for (int i = 0; i < this.archive.getAccordiServizioParteComune().size(); i++) {
  1580.                             ArchiveAccordoServizioParteComune archiveAccordo = this.archive.getAccordiServizioParteComune().get(i);
  1581.                             IDAccordo idAccordo = this.idAccordoFactory.getIDAccordoFromAccordo(archiveAccordo.getAccordoServizioParteComune());
  1582.                             if(idAccordo.equals(this.idAccordoFactory.getIDAccordoFromUri(uriAPC))){
  1583.                                 found = true;
  1584.                                 aspc = archiveAccordo.getAccordoServizioParteComune();
  1585.                                 break;
  1586.                             }
  1587.                         }
  1588.                     }
  1589.                     if(!found){
  1590.                         if(this.archive.getAccordiServizioComposto()!=null && this.archive.getAccordiServizioComposto().size()>0){
  1591.                             for (int i = 0; i < this.archive.getAccordiServizioComposto().size(); i++) {
  1592.                                 ArchiveAccordoServizioParteComune archiveAccordo = this.archive.getAccordiServizioComposto().get(i);
  1593.                                 IDAccordo idAccordo = this.idAccordoFactory.getIDAccordoFromAccordo(archiveAccordo.getAccordoServizioParteComune());
  1594.                                 if(idAccordo.equals(this.idAccordoFactory.getIDAccordoFromUri(uriAPC))){
  1595.                                     found = true;
  1596.                                     aspc = archiveAccordo.getAccordoServizioParteComune();
  1597.                                     break;
  1598.                                 }
  1599.                             }
  1600.                         }
  1601.                     }
  1602.                     if(!found){
  1603.                         throw new ProtocolException("Accordo di Servizio Parte Comune ["+uriAPC+"], riferito dall'archivio, non esiste",notFound);
  1604.                     }
  1605.                 }
  1606.             }
  1607.             
  1608.             
  1609.             // *** campi da verificare ***
  1610.             String tipoSoggettoErogatore = asps.getTipoSoggettoErogatore();
  1611.             String nomeSoggettoErogatore = asps.getNomeSoggettoErogatore();
  1612.             Integer versione = asps.getVersione();
  1613.                                 
  1614.             if(tipoSoggettoErogatore==null || nomeSoggettoErogatore==null || versione==null || aspc==null ){
  1615.                 
  1616.                 // provo ad utilizzare le informazioni eventualmente presenti nell'oggetto importInformationMissing
  1617.                 // se non sono presenti nemmeno in tale oggetto, sollevo eccezione
  1618.                 ImportInformationMissingException infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  1619.                 boolean throwException = false;
  1620.                 
  1621.                 // soggetto
  1622.                 if(tipoSoggettoErogatore==null || nomeSoggettoErogatore==null){
  1623.                     if(importInformationMissing!=null && importInformationMissing.getSoggetto()!=null){
  1624.                         if(!this.registryReader.existsSoggetto(importInformationMissing.getSoggetto())){
  1625.                             // verifico che non esista nell'archivio che sto importanto
  1626.                             boolean found = false;
  1627.                             if(this.archive.getSoggetti()!=null && this.archive.getSoggetti().size()>0){
  1628.                                 for (int i = 0; i < this.archive.getSoggetti().size(); i++) {
  1629.                                     ArchiveSoggetto archiveSoggetto = this.archive.getSoggetti().get(i);
  1630.                                     if(archiveSoggetto.getIdSoggetto().equals(importInformationMissing.getSoggetto())){
  1631.                                         found = true;
  1632.                                         break;
  1633.                                     }
  1634.                                 }
  1635.                             }
  1636.                             if(!found){
  1637.                                 throw new ProtocolException("Il Soggetto "+importInformationMissing.getSoggetto().toString()+" non esiste (indicato in ImportInformationMissing parameter??)");
  1638.                             }
  1639.                         }
  1640.                         asps.setTipoSoggettoErogatore(importInformationMissing.getSoggetto().getTipo());
  1641.                         asps.setNomeSoggettoErogatore(importInformationMissing.getSoggetto().getNome());
  1642. //                      if(asps.getServizio().getConnettore().getNome()==null){
  1643. //                          String nomeConn = "CNT_" + importInformationMissing.getSoggetto().getTipo() + "/" + importInformationMissing.getSoggetto().getNome() + "_" +
  1644. //                                  asps.getServizio().getTipo() + "/" + asps.getServizio().getNome();
  1645. //                          asps.getServizio().getConnettore().setNome(nomeConn);
  1646. //                      }
  1647.                     }else{
  1648.                         infoException.setMissingInfoSoggetto(true);
  1649.                         throwException = true;
  1650.                     }
  1651.                 }
  1652.                 
  1653.                 // versione
  1654.                 if(versione==null){
  1655.                     if(importInformationMissing!=null && importInformationMissing.getVersione()!=null){
  1656.                         asps.setVersione(importInformationMissing.getVersione());
  1657.                     }else{
  1658.                         infoException.setMissingInfoVersione(true);
  1659.                         throwException = true;
  1660.                     }
  1661.                 }
  1662.                 
  1663.                 // accordoServizioParteComune
  1664.                 if(aspc==null){
  1665.                     if(importInformationMissing!=null && importInformationMissing.getIdAccordoServizioParteComune()!=null){
  1666.                         asps.setAccordoServizioParteComune(this.idAccordoFactory.getUriFromIDAccordo(importInformationMissing.getIdAccordoServizioParteComune()));
  1667.                     }else{
  1668.                         infoException.setMissingInfoAccordoServizioParteComune(true);
  1669.                         throwException = true;
  1670.                     }
  1671.                 }
  1672.                 
  1673.                 // se e' stata rilevata una mancanza sollevo eccezione
  1674.                 if(throwException)
  1675.                     throw infoException;
  1676.             }
  1677.             
  1678.             
  1679.             if(aspc!=null){
  1680.                 
  1681.                 // *** Verifica documenti presenti all'interno del package ***
  1682.                 List<String> serviziIdentificatiNellaParteComune = this.letturaServiziDefinitiParteComune(asps, aspc);
  1683.                 if(this.validateDocuments){                     
  1684.                     
  1685.                     ValidazioneResult result = this.validatoreDocumenti.validaSpecificaInterfaccia(asps, aspc);
  1686.                     if(result.isEsito()==false){
  1687.                         if(result.getException()!=null)
  1688.                             throw new Exception(result.getMessaggioErrore(),result.getException());
  1689.                         else
  1690.                             throw new Exception(result.getMessaggioErrore());
  1691.                     }
  1692.                     
  1693.                     result = this.validatoreDocumenti.validaDocumenti(asps);
  1694.                     if(result.isEsito()==false){
  1695.                         if(result.getException()!=null)
  1696.                             throw new Exception(result.getMessaggioErrore(),result.getException());
  1697.                         else
  1698.                             throw new Exception(result.getMessaggioErrore());
  1699.                     }
  1700.                     
  1701.                     verificaMappingPortTypeBindingInRiferimentoParteComune(asps, aspc, serviziIdentificatiNellaParteComune);
  1702.                 
  1703.                 }
  1704.                 
  1705.                 
  1706.                 // *** Verifica portType riferito ***
  1707.                 if(importInformationMissing!=null && importInformationMissing.getPortTypeImplemented()!=null){
  1708.                     // Il nome deve essere gia' corretto dentro l'archivio. Altrimenti tutti i riferimenti poi (mapping.id, porte applicative ....) sono sbagliati.
  1709. //                  if(asps.getPortType()!=null && asps.getPortType().equals(asps.getNome())){
  1710. //                      asps.setNome(importInformationMissing.getPortTypeImplemented());
  1711. //                  }
  1712.                     asps.setPortType(importInformationMissing.getPortTypeImplemented());
  1713.                 }
  1714.                 if(asps.getPortType()!=null){
  1715.                     if(serviziIdentificatiNellaParteComune.contains(asps.getPortType())==false){
  1716.                         ImportInformationMissingException infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  1717.                         infoException.setMismatchPortTypeRifServiziParteComune(true, asps.getPortType(), serviziIdentificatiNellaParteComune);
  1718.                         throw infoException;
  1719.                     }
  1720.                 }   
  1721.                 
  1722.             }
  1723.             
  1724.         }catch(ImportInformationMissingException e){
  1725.             throw e;
  1726.         }catch(Exception e){
  1727.             throw new Exception(objectIdDescription+" validazione fallita: "+e.getMessage(),e);
  1728.         }
  1729.         
  1730.     }
  1731.     
  1732.     private List<String> letturaServiziDefinitiParteComune(Fruitore fruitore,AccordoServizioParteSpecifica asps,AccordoServizioParteComune aspc){
  1733.         Boolean correlato = null;
  1734.         
  1735.         // Identificazione attraverso WSDL Implementativo
  1736.         if(fruitore.getByteWsdlImplementativoErogatore()!=null){
  1737.             correlato = false;
  1738.         }
  1739.         else if(fruitore.getByteWsdlImplementativoFruitore()!=null){
  1740.             correlato = true;
  1741.         }
  1742.         else if(asps.getByteWsdlImplementativoErogatore()!=null){
  1743.             correlato = false;
  1744.         }
  1745.         else if(asps.getByteWsdlImplementativoFruitore()!=null){
  1746.             correlato = true;
  1747.         }
  1748.         
  1749.         // Identificazione attraverso tipologia
  1750.         if(correlato==null){
  1751.             TipologiaServizio tipologiaServizio = TipologiaServizio.NORMALE;
  1752.             if(asps!=null){
  1753.                 tipologiaServizio = asps.getTipologiaServizio();
  1754.             }
  1755.             correlato = TipologiaServizio.CORRELATO.equals(tipologiaServizio);
  1756.         }
  1757.         
  1758.         return this.letturaServiziDefinitiParteComune(correlato, aspc); 
  1759.     }
  1760.     private List<String> letturaServiziDefinitiParteComune(AccordoServizioParteSpecifica asps,AccordoServizioParteComune aspc){
  1761.         Boolean correlato = null;
  1762.         
  1763.         // Identificazione attraverso WSDL Implementativo
  1764.         if(asps!=null && asps.getByteWsdlImplementativoErogatore()!=null){
  1765.             correlato = false;
  1766.         }
  1767.         else if(asps!=null && asps.getByteWsdlImplementativoFruitore()!=null){
  1768.             correlato = true;
  1769.         }
  1770.         
  1771.         // Identificazione attraverso tipologia
  1772.         if(correlato==null){
  1773.             TipologiaServizio tipologiaServizio = TipologiaServizio.NORMALE;
  1774.             if(asps!=null){
  1775.                 tipologiaServizio = asps.getTipologiaServizio();
  1776.             }
  1777.             correlato = TipologiaServizio.CORRELATO.equals(tipologiaServizio);
  1778.         }
  1779.         
  1780.         return this.letturaServiziDefinitiParteComune(correlato, aspc); 
  1781.     }
  1782.     private List<String> letturaServiziDefinitiParteComune(boolean correlato,AccordoServizioParteComune aspc){
  1783.         List<String> serviziIdentificatiNellaParteComune = new ArrayList<>();
  1784.                 
  1785.         // Lettura Accordo di Servizio Parte Comune di OpenSPCoop
  1786.         // NOTA: aspc di openspcoop contiene sia le parti comuni "normali" che quelle "servizio composto"
  1787.         for(int i=0; i<aspc.sizePortTypeList(); i++){
  1788.             // faccio vedere solo i servizi correlati o i servizi normali, a seconda se e' stato fornito il wsdl implementativo fruitore o erogatore
  1789.             PortType pt = aspc.getPortType(i);
  1790.             boolean servizioCorrelato = false;
  1791.             for(int j=0; j<pt.sizeAzioneList(); j++){
  1792.                 Operation op = pt.getAzione(j);
  1793.                 // NOTA: solo un asincrono simmetrico o asincrono asimmetrico (verso servizio diverso) e' correlato!
  1794.                 if(op.getCorrelataServizio()!=null && !pt.getNome().equals(op.getCorrelataServizio()) && op.getCorrelata()!=null){
  1795.                     servizioCorrelato = true;
  1796.                     break;
  1797.                 }
  1798.             }
  1799.             if(correlato){
  1800.                 if(servizioCorrelato){
  1801.                     serviziIdentificatiNellaParteComune.add(aspc.getPortType(i).getNome());
  1802.                 }
  1803.             }else{
  1804.                 if(!servizioCorrelato){
  1805.                     serviziIdentificatiNellaParteComune.add(aspc.getPortType(i).getNome());
  1806.                 }
  1807.             }
  1808.         }
  1809.         
  1810.         return serviziIdentificatiNellaParteComune;
  1811.     }
  1812.     
  1813.     private void verificaMappingPortTypeBindingInRiferimentoParteComune(Fruitore fruitore,AccordoServizioParteSpecifica asps, 
  1814.             AccordoServizioParteComune aspc,
  1815.             List<String> serviziIdentificatiNellaParteComune) throws Exception {
  1816.         // Identificazione WSDL Implementativo
  1817.         byte[]wsdlImplementativo = null;
  1818.         String tipoWSDL = "WSDL Implementativo";
  1819.         if(fruitore.getByteWsdlImplementativoErogatore()!=null){
  1820.             wsdlImplementativo = asps.getByteWsdlImplementativoErogatore();
  1821.             tipoWSDL = "WSDL Implementativo Erogatore";
  1822.         }
  1823.         else if(fruitore.getByteWsdlImplementativoFruitore()!=null){
  1824.             wsdlImplementativo = asps.getByteWsdlImplementativoFruitore();
  1825.             tipoWSDL = "WSDL Implementativo Fruitore";
  1826.         }
  1827.         else if(asps.getByteWsdlImplementativoErogatore()!=null){
  1828.             wsdlImplementativo = asps.getByteWsdlImplementativoErogatore();
  1829.             tipoWSDL = "WSDL Implementativo Erogatore";
  1830.         }
  1831.         else if(asps.getByteWsdlImplementativoFruitore()!=null){
  1832.             wsdlImplementativo = asps.getByteWsdlImplementativoFruitore();
  1833.             tipoWSDL = "WSDL Implementativo Fruitore";
  1834.         }
  1835.         if(wsdlImplementativo!=null){
  1836.             this.verificaMappingPortTypeBindingInRiferimentoParteComune(wsdlImplementativo, tipoWSDL, aspc, serviziIdentificatiNellaParteComune);
  1837.         }
  1838.     }
  1839.     private void verificaMappingPortTypeBindingInRiferimentoParteComune(AccordoServizioParteSpecifica asps, 
  1840.             AccordoServizioParteComune aspc,
  1841.             List<String> serviziIdentificatiNellaParteComune) throws Exception {
  1842.         // Identificazione WSDL Implementativo
  1843.         byte[]wsdlImplementativo = null;
  1844.         String tipoWSDL = "WSDL Implementativo";
  1845.         if(asps.getByteWsdlImplementativoErogatore()!=null){
  1846.             wsdlImplementativo = asps.getByteWsdlImplementativoErogatore();
  1847.             tipoWSDL = "WSDL Implementativo Erogatore";
  1848.         }
  1849.         else if(asps.getByteWsdlImplementativoFruitore()!=null){
  1850.             wsdlImplementativo = asps.getByteWsdlImplementativoFruitore();
  1851.             tipoWSDL = "WSDL Implementativo Fruitore";
  1852.         }
  1853.         if(wsdlImplementativo!=null){
  1854.             this.verificaMappingPortTypeBindingInRiferimentoParteComune(wsdlImplementativo, tipoWSDL, aspc, serviziIdentificatiNellaParteComune);
  1855.         }
  1856.     }
  1857.     private void verificaMappingPortTypeBindingInRiferimentoParteComune( byte[]wsdlImplementativo,String tipoWSDL,
  1858.             AccordoServizioParteComune aspc,
  1859.             List<String> serviziIdentificatiNellaParteComune) throws Exception {
  1860.         
  1861.         List<String> portTypesImplemented = new ArrayList<>();
  1862.         try{
  1863.                                     
  1864.             // Lettura WSDL Parte Specifica
  1865.             Document d = this.xmlUtils.newDocument(wsdlImplementativo);
  1866.             DefinitionWrapper wsdl = new DefinitionWrapper(d,this.xmlUtils,false,false);
  1867.             Map<QName,QName> mapBindingToPortTypeImplemented = wsdl.getMapPortTypesImplementedBinding();
  1868.             for (QName binding : mapBindingToPortTypeImplemented.keySet()) {
  1869.                 QName portType = mapBindingToPortTypeImplemented.get(binding);
  1870.                 String portTypeName = portType.getLocalPart();
  1871.                 if(portTypesImplemented.contains(portTypeName)==false){
  1872.                     portTypesImplemented.add(portTypeName);
  1873.                 }
  1874.             }
  1875.         }catch(Exception e){
  1876.             String msgErrore = "La verifica dei port-types, implementati dai binding del "+tipoWSDL+", rispetto ai servizi definiti nell'accordo di servizio parte comune, ha riscontrato un errore: "+e.getMessage();
  1877.             this.protocolFactory.getLogger().error(msgErrore,e);
  1878.             throw new Exception(msgErrore,e);
  1879.         }
  1880.                     
  1881.         // Controllo
  1882.         for (String pt : portTypesImplemented) {                
  1883.             boolean trovato = false;
  1884.             for (String servizioOpenSPCoop : serviziIdentificatiNellaParteComune) {
  1885.                 if(pt.equals(servizioOpenSPCoop)){
  1886.                     trovato=true;
  1887.                     break;
  1888.                 }
  1889.             }
  1890.             if(!trovato){
  1891.                 throw new Exception("Il PortType "+pt+" implementato nei binding presenti nel "+tipoWSDL+" non è uno dei servizi definiti nell'accordo di servizio parte comune");
  1892.             }
  1893.         }

  1895.     }
  1896.     
  1897.     
  1898.     
  1899.     @SuppressWarnings("deprecation")
  1900.     public void validateAndFillFruitore(ArchiveFruitore archiveFruitore) throws Exception{
  1901.         
  1902.         // *** object id ***
  1903.         Fruitore fruitore = archiveFruitore.getFruitore();
  1904.         IDServizio asps = archiveFruitore.getIdAccordoServizioParteSpecifica();
  1905.         String uri = fruitore.getTipo()+"/"+fruitore.getNome()+"_"+this.idServizioFactory.getUriFromIDServizio(asps);
  1906.         String objectId = "[[Fruitore]]"+uri; 
  1907.         String objectIdDescription = "Fruitore ["+fruitore.getTipo()+"/"+fruitore.getNome()
  1908.                 +"] dell'Accordo di Servizio Parte Specifica ["+this.idServizioFactory.getUriFromIDServizio(asps)+"]";
  1909.         ImportInformationMissing importInformationMissing = null;
  1910.         if(this.importInformationMissingCollection!=null){
  1911.             importInformationMissing = this.importInformationMissingCollection.get(objectId);
  1912.         }
  1913.         
  1914.         
  1915.         try{
  1916.                     
  1917.             // *** campi da verificare ***
  1918.             String tipoSoggettoErogatore = null;
  1919.             String nomeSoggettoErogatore = null;
  1920.             if(asps.getSoggettoErogatore()!=null){
  1921.                 tipoSoggettoErogatore = asps.getSoggettoErogatore().getTipo();
  1922.                 nomeSoggettoErogatore = asps.getSoggettoErogatore().getNome();
  1923.             }
  1924.             Integer versione = asps.getVersione();
  1925.                                 
  1926.             if(tipoSoggettoErogatore==null || nomeSoggettoErogatore==null || versione==null ){
  1927.                 
  1928.                 // provo ad utilizzare le informazioni eventualmente presenti nell'oggetto importInformationMissing
  1929.                 // se non sono presenti nemmeno in tale oggetto, sollevo eccezione
  1930.                 ImportInformationMissingException infoException = new ImportInformationMissingException(objectId,objectIdDescription);
  1931.                 boolean throwException = false;
  1932.                 
  1933.                 // soggetto
  1934.                 if(tipoSoggettoErogatore==null || nomeSoggettoErogatore==null){
  1935.                     if(importInformationMissing!=null && importInformationMissing.getSoggetto()!=null){
  1936.                         if(!this.registryReader.existsSoggetto(importInformationMissing.getSoggetto())){
  1937.                             // verifico che non esista nell'archivio che sto importanto
  1938.                             boolean found = false;
  1939.                             if(this.archive.getSoggetti()!=null && this.archive.getSoggetti().size()>0){
  1940.                                 for (int i = 0; i < this.archive.getSoggetti().size(); i++) {
  1941.                                     ArchiveSoggetto archiveSoggetto = this.archive.getSoggetti().get(i);
  1942.                                     if(archiveSoggetto.getIdSoggetto().equals(importInformationMissing.getSoggetto())){
  1943.                                         found = true;
  1944.                                         break;
  1945.                                     }
  1946.                                 }
  1947.                             }
  1948.                             if(!found){
  1949.                                 throw new ProtocolException("Il Soggetto "+importInformationMissing.getSoggetto().toString()+" non esiste (indicato in ImportInformationMissing parameter??)");
  1950.                             }
  1951.                         }
  1952.                         if(asps.getSoggettoErogatore()==null){
  1953.                             asps.setSoggettoErogatore(importInformationMissing.getSoggetto());
  1954.                         }
  1955.                     }else{
  1956.                         infoException.setMissingInfoSoggetto(true);
  1957.                         throwException = true;
  1958.                     }
  1959.                 }
  1960.                 
  1961.                 // versione
  1962.                 if(versione==null){
  1963.                     if(importInformationMissing!=null && importInformationMissing.getVersione()!=null){
  1964.                         asps.setVersione(importInformationMissing.getVersione());
  1965.                     }else{
  1966.                         infoException.setMissingInfoVersione(true);
  1967.                         throwException = true;
  1968.                     }
  1969.                 }
  1970.                 
  1971.                 // se e' stata rilevata una mancanza sollevo eccezione
  1972.                 if(throwException)
  1973.                     throw infoException;
  1974.             }
  1975.             
  1976.             
  1977.             // *** Verifica riferimento Parte Specifica ***
  1978.             AccordoServizioParteSpecifica accordoAsps = null;
  1979.             try{
  1980.                 accordoAsps = this.registryReader.getAccordoServizioParteSpecifica(asps);
  1981.                 if(accordoAsps==null){
  1982.                     throw new Exception("getAccordoServizioParteSpecifica return null"); 
  1983.                 }
  1984.             //}catch(RegistryNotFound notFound){
  1985.             }catch(Exception notFound){ // Se non esiste il soggetto, il metodo sopra ritorna null, poichè il driver non ritorna notFound. Questo succede se il soggetto è nell'archivio
  1986.                 // verifico che non esista nell'archivio che sto importanto
  1987.                 boolean found = false;
  1988.                 if(this.archive.getAccordiServizioParteSpecifica()!=null && this.archive.getAccordiServizioParteSpecifica().size()>0){
  1989.                     for (int i = 0; i < this.archive.getAccordiServizioParteSpecifica().size(); i++) {
  1990.                         ArchiveAccordoServizioParteSpecifica archiveAccordo = this.archive.getAccordiServizioParteSpecifica().get(i);
  1991.                         IDServizio idAccordo = this.idServizioFactory.getIDServizioFromAccordo(archiveAccordo.getAccordoServizioParteSpecifica());
  1992.                         if(idAccordo.equals(asps)){
  1993.                             found = true;
  1994.                             accordoAsps = archiveAccordo.getAccordoServizioParteSpecifica();
  1995.                             break;
  1996.                         }
  1997.                     }
  1998.                 }
  1999.                 if(!found){
  2000.                     throw new ProtocolException("Accordo di Servizio Parte Specifica ["+asps+"], riferito dall'archivio fruitore, non esiste",notFound);
  2001.                 }
  2002.             }
  2003.             
  2004.             
  2005.             
  2006.             // *** Verifica riferimento Parte Comune ***
  2007.             AccordoServizioParteComune aspc = null;
  2008.             String uriAPC = null;
  2009.             try{
  2010.                 // Il riferimento potrebbe contenere un nome dinamico rispetto all'erogatore
  2011.                 uriAPC = accordoAsps.getAccordoServizioParteComune();
  2012.                 if(uriAPC!=null) {
  2013.                     uriAPC = ImporterInformationMissingSetter.replaceSoggettoProprietarioOrDefault(this.registryReader, uriAPC, asps.getSoggettoErogatore().getTipo(), asps.getSoggettoErogatore().getNome());
  2014.                     uriAPC = ImporterInformationMissingSetter.replaceSoggettoErogatore(uriAPC, asps.getSoggettoErogatore().getTipo(), asps.getSoggettoErogatore().getNome());
  2015.                 }
  2016.                 
  2017.                 aspc = this.registryReader.getAccordoServizioParteComune(this.idAccordoFactory.getIDAccordoFromUri(uriAPC));
  2018.                 if(aspc==null){
  2019.                     throw new Exception("getAccordoServizioParteComune return null"); 
  2020.                 }
  2021.             //}catch(RegistryNotFound notFound){
  2022.             }catch(Exception notFound){ // Se non esiste il soggetto, il metodo sopra ritorna null, poichè il driver non ritorna notFound. Questo succede se il soggetto è nell'archivio
  2023.                 // verifico che non esista nell'archivio che sto importanto
  2024.                 boolean found = false;
  2025.                 if(this.archive.getAccordiServizioParteComune()!=null && this.archive.getAccordiServizioParteComune().size()>0){
  2026.                     for (int i = 0; i < this.archive.getAccordiServizioParteComune().size(); i++) {
  2027.                         ArchiveAccordoServizioParteComune archiveAccordo = this.archive.getAccordiServizioParteComune().get(i);
  2028.                         IDAccordo idAccordo = this.idAccordoFactory.getIDAccordoFromAccordo(archiveAccordo.getAccordoServizioParteComune());
  2029.                         if(idAccordo.equals(this.idAccordoFactory.getIDAccordoFromUri(uriAPC))){
  2030.                             found = true;
  2031.                             aspc = archiveAccordo.getAccordoServizioParteComune();
  2032.                             break;
  2033.                         }
  2034.                     }
  2035.                 }
  2036.                 if(!found){
  2037.                     if(this.archive.getAccordiServizioComposto()!=null && this.archive.getAccordiServizioComposto().size()>0){
  2038.                         for (int i = 0; i < this.archive.getAccordiServizioComposto().size(); i++) {
  2039.                             ArchiveAccordoServizioParteComune archiveAccordo = this.archive.getAccordiServizioComposto().get(i);
  2040.                             IDAccordo idAccordo = this.idAccordoFactory.getIDAccordoFromAccordo(archiveAccordo.getAccordoServizioParteComune());
  2041.                             if(idAccordo.equals(this.idAccordoFactory.getIDAccordoFromUri(uriAPC))){
  2042.                                 found = true;
  2043.                                 aspc = archiveAccordo.getAccordoServizioParteComune();
  2044.                                 break;
  2045.                             }
  2046.                         }
  2047.                     }
  2048.                 }
  2049.                 if(!found){
  2050.                     throw new ProtocolException("Accordo di Servizio Parte Comune ["+uriAPC+
  2051.                             "], riferito dall'accordo parte specifica dell'archivio fruitore, non esiste",notFound);
  2052.                 }
  2053.             }
  2054.             
  2055.             
  2056.             
  2057.             // *** Verifica documenti presenti all'interno del package ***
  2058.             List<String> serviziIdentificatiNellaParteComune = this.letturaServiziDefinitiParteComune(fruitore,accordoAsps, aspc);
  2059.             if(this.validateDocuments){                     
  2060.                 
  2061.                 ValidazioneResult result = this.validatoreDocumenti.validaSpecificaInterfaccia(fruitore,accordoAsps, aspc);
  2062.                 if(result.isEsito()==false){
  2063.                     if(result.getException()!=null)
  2064.                         throw new Exception(result.getMessaggioErrore(),result.getException());
  2065.                     else
  2066.                         throw new Exception(result.getMessaggioErrore());
  2067.                 }
  2068.                                 
  2069.                 verificaMappingPortTypeBindingInRiferimentoParteComune(fruitore, accordoAsps, aspc, serviziIdentificatiNellaParteComune);
  2070.             
  2071.             }
  2072.                         
  2073.         }catch(ImportInformationMissingException e){
  2074.             throw e;
  2075.         }catch(Exception e){
  2076.             throw new Exception(objectIdDescription+" validazione fallita: "+e.getMessage(),e);
  2077.         }
  2078.         
  2079.     }
  2080. }
Created with JaCoCo 0.8.8.202204050719