AccordoServizioParteComuneMappingCore.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.  */
  20. package org.openspcoop2.web.ctrlstat.servlet.apc;

  22. import java.util.ArrayList;
  23. import java.util.List;
  24. import java.util.Map;

  26. import org.openspcoop2.core.id.IDAccordo;
  27. import org.openspcoop2.core.id.IDPortType;
  28. import org.openspcoop2.core.id.IDPortTypeAzione;
  29. import org.openspcoop2.core.id.IDResource;
  30. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  31. import org.openspcoop2.core.registry.Documento;
  32. import org.openspcoop2.core.registry.Operation;
  33. import org.openspcoop2.core.registry.PortType;
  34. import org.openspcoop2.core.registry.Resource;
  35. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  36. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  37. import org.openspcoop2.core.registry.constants.FormatoSpecifica;
  38. import org.openspcoop2.core.registry.constants.RuoliDocumento;
  39. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  40. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  41. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  42. import org.openspcoop2.message.xml.MessageXMLUtils;
  43. import org.openspcoop2.message.xml.XMLDiff;
  44. import org.openspcoop2.protocol.basic.Costanti;
  45. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  46. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  47. import org.openspcoop2.utils.LoggerWrapperFactory;
  48. import org.openspcoop2.utils.rest.ApiFactory;
  49. import org.openspcoop2.utils.rest.ApiFormats;
  50. import org.openspcoop2.utils.rest.ApiReaderConfig;
  51. import org.openspcoop2.utils.rest.IApiReader;
  52. import org.openspcoop2.utils.rest.api.Api;
  53. import org.openspcoop2.utils.wsdl.WSDLUtilities;
  54. import org.openspcoop2.utils.xml.AbstractXMLUtils;
  55. import org.openspcoop2.utils.xml.XSDUtils;
  56. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  57. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  58. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaAdd;
  59. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiviCore;
  60. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  61. import org.openspcoop2.web.lib.mvc.ServletUtils;
  62. import org.w3c.dom.Document;
  63. import org.w3c.dom.Element;
  64. import org.w3c.dom.Node;

  66. /**
  67.  * AccordoServizioParteComuneMappingCore
  68.  *
  69.  * @author Poli Andrea (apoli@link.it)
  70.  * @author $Author$
  71.  * @version $Rev$, $Date$
  72.  */
  73. public class AccordoServizioParteComuneMappingCore extends ControlStationCore {

  75.     protected AccordoServizioParteComuneMappingCore(ControlStationCore core) throws DriverControlStationException {
  76.         super(core);
  77.     }
  78.     
  79.     public void mappingAutomatico(String protocollo , AccordoServizioParteComune as, boolean validazioneDocumenti) throws DriverRegistroServiziException {
  80.         String nomeMetodo = "mappingAutomatico";
  81.         try {
  82.             IProtocolFactory<?> protocol = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  83.             protocol.createArchive().setProtocolInfo(as);
  84.         }catch (Exception e) {
  85.             if(validazioneDocumenti) {
  86.                 ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  87.                 throw new DriverRegistroServiziException(getPrefixError(nomeMetodo,  e), e);
  88.             }
  89.         }
  90.     }

  92.     
  93.     public void popolaResourceDaUnAltroASPC(AccordoServizioParteComune aspcDestinazione, AccordoServizioParteComune aspcSorgente, 
  94.             boolean aggiornaRisorseEsistenti, boolean eliminaRisorseNonPresentiNuovaInterfaccia, List<IDResource> risorseEliminate) throws DriverRegistroServiziException{
  95.         String nomeMetodo = "popolaResourceDaUnAltroASPC";
  96.         try {
  97.             if(aspcSorgente.sizeResourceList() > 0){
  98.                 for (Resource nuovoResource : aspcSorgente.getResourceList()) {
  99.                     
  100.                     Resource vecchioResourceByMethodPath = find(nuovoResource, aspcDestinazione.getResourceList());
  101.                     
  102.                     // non ho trovato l'elemento corrente nel aspc destinazione
  103.                     if(vecchioResourceByMethodPath == null){
  104.                         
  105.                         // prima di aggiungerlo, avendolo cercato per method/path verifico che lo stesso nome non sia stato utilizzato per unl'altra risorsa
  106.                         boolean foundName = true;
  107.                         int index = 2;
  108.                         while(foundName) {
  109.                             foundName = false;
  110.                             for (Resource vecchioResourceTMP : aspcDestinazione.getResourceList()) {
  111.                                 if(vecchioResourceTMP.getNome().equals(nuovoResource.getNome())){
  112.                                     foundName = true;
  113.                                     break;
  114.                                 }
  115.                             }
  116.                             
  117.                             if(foundName) {
  118.                                 nuovoResource.setNome(nuovoResource.getNome()+"_"+index);
  119.                                 index++;
  120.                             }
  121.                         }
  122.                         
  123.                         aspcDestinazione.addResource(nuovoResource);
  124.                     } else {
  125.                         if(aggiornaRisorseEsistenti) {
  126.                             // ho trovato l'elemento, aggiorno i valori  rimpiazzando la risorsa
  127.                             Resource vecchiaResource = null;
  128.                             for (int i = 0; i < aspcDestinazione.sizeResourceList(); i++) {
  129.                                 if(aspcDestinazione.getResource(i).getNome().equals(vecchioResourceByMethodPath.getNome())) {
  130.                                     vecchiaResource = aspcDestinazione.removeResource(i);
  131.                                     break;
  132.                                 }
  133.                             }
  134.                             aspcDestinazione.addResource(nuovoResource);
  135.                             
  136.                             if(vecchiaResource!=null) {

  138.                                 // riporto eventuali properties
  139.                                 if(vecchiaResource.sizeProtocolPropertyList()>0) {
  140.                                     for (int i = 0; i < vecchiaResource.sizeProtocolPropertyList(); i++) {
  141.                                         nuovoResource.addProtocolProperty(vecchiaResource.getProtocolProperty(i));      
  142.                                     }
  143.                                 }
  144.                                 
  145.                                 if(!CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO.equals(vecchiaResource.getProfAzione())) {
  146.                                     continue;
  147.                                 }

  149.                                 boolean ridefinisci = false;
  150.                                 if(vecchiaResource.getConfermaRicezione()!=null && org.openspcoop2.core.registry.constants.StatoFunzionalita.ABILITATO.equals(vecchiaResource.getConfermaRicezione())) {
  151.                                     nuovoResource.setConfermaRicezione(vecchiaResource.getConfermaRicezione());
  152.                                     ridefinisci = true;
  153.                                 }
  154.                                 if(vecchiaResource.getConsegnaInOrdine()!=null && org.openspcoop2.core.registry.constants.StatoFunzionalita.ABILITATO.equals(vecchiaResource.getConsegnaInOrdine())) {
  155.                                     nuovoResource.setConsegnaInOrdine(vecchiaResource.getConsegnaInOrdine());
  156.                                     ridefinisci = true;
  157.                                 }
  158.                                 if(vecchiaResource.getIdCollaborazione()!=null && org.openspcoop2.core.registry.constants.StatoFunzionalita.ABILITATO.equals(vecchiaResource.getIdCollaborazione())) {
  159.                                     nuovoResource.setIdCollaborazione(vecchiaResource.getIdCollaborazione());
  160.                                     ridefinisci = true;
  161.                                 }
  162.                                 if(vecchiaResource.getIdRiferimentoRichiesta()!=null && org.openspcoop2.core.registry.constants.StatoFunzionalita.ABILITATO.equals(vecchiaResource.getIdRiferimentoRichiesta())) {
  163.                                     nuovoResource.setIdRiferimentoRichiesta(vecchiaResource.getIdRiferimentoRichiesta());
  164.                                     ridefinisci = true;
  165.                                 }
  166.                                 if(vecchiaResource.getScadenza()!=null && !"".equals(vecchiaResource.getScadenza())) {
  167.                                     nuovoResource.setScadenza(vecchiaResource.getScadenza());
  168.                                     ridefinisci = true;
  169.                                 }
  170.                                 if(vecchiaResource.getDescrizione()!=null && !"".equals(vecchiaResource.getDescrizione())) {
  171.                                     nuovoResource.setDescrizione(vecchiaResource.getDescrizione());
  172.                                     ridefinisci = true;
  173.                                 }
  174.                                 // filtro duplicati gestito nel BasicArchive.setProtocolInfo
  175.                                 if(vecchiaResource.getFiltroDuplicati()!=null &&
  176.                                     !vecchiaResource.getFiltroDuplicati().equals(nuovoResource.getFiltroDuplicati())) {
  177.                                     nuovoResource.setFiltroDuplicati(vecchiaResource.getFiltroDuplicati());
  178.                                     ridefinisci = true;
  179.                                 }
  180.                                 if(ridefinisci) {
  181.                                     nuovoResource.setProfAzione(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO);
  182.                                 }
  183.                                 
  184.                             }
  185.                         }
  186.                     }
  187.                 }
  188.             }
  189.             
  190.             if(eliminaRisorseNonPresentiNuovaInterfaccia) {
  191.                 
  192.                 IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromAccordo(aspcDestinazione);
  193.                 
  194.                 if(aspcDestinazione.sizeResourceList() > 0){
  195.                     List<Resource> risorseDaEliminare = new ArrayList<>();
  196.                     for (Resource oldResource : aspcDestinazione.getResourceList()) {
  197.                         
  198.                         Resource find = find(oldResource, aspcSorgente.getResourceList());
  199.                         if(find==null) {
  200.                             risorseDaEliminare.add(oldResource);
  201.                         }
  202.                         
  203.                     }
  204.                     while(!risorseDaEliminare.isEmpty()) {
  205.                         Resource risorsaDaEliminare = risorseDaEliminare.remove(0);
  206.                         for (int i = 0; i < aspcDestinazione.sizeResourceList(); i++) {
  207.                             if(aspcDestinazione.getResource(i).getNome().equals(risorsaDaEliminare.getNome())) {
  208.                                 aspcDestinazione.removeResource(i);
  209.                                 IDResource idResource = new IDResource();
  210.                                 idResource.setIdAccordo(idAccordo);
  211.                                 idResource.setNome(risorsaDaEliminare.getNome());
  212.                                 
  213.                                 risorseEliminate.add(idResource);
  214.                                 
  215.                                 break;
  216.                             }
  217.                         }
  218.                     }
  219.                 }
  220.             }
  221.         }
  222.         catch (Exception e) {
  223.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  224.             throw e;
  225.         }
  226.     }
  227.     
  228.     private Resource find(Resource resourceSearched, List<Resource> resources) {
  229.         if(resources==null || resources.isEmpty()) {
  230.             return null;
  231.         }
  232.         Resource resourceByMethodPath = null;
  233.         for (Resource resourceTMP : resources) {
  234.             
  235.             if(resourceTMP.getMethod()==null) {
  236.                 if(resourceSearched.getMethod()!=null) {
  237.                     continue;
  238.                 }
  239.             }else {
  240.                 if(!resourceTMP.getMethod().equals(resourceSearched.getMethod())) {
  241.                     continue;
  242.                 }
  243.             }
  244.             
  245.             if(resourceTMP.getPath()==null) {
  246.                 if(resourceSearched.getPath()!=null) {
  247.                     continue;
  248.                 }
  249.             }else {
  250.                 if(!resourceTMP.getPath().equals(resourceSearched.getPath())) {
  251.                     continue;
  252.                 }
  253.             }
  254.             
  255.             resourceByMethodPath = resourceTMP;
  256.             break;
  257.         }   
  258.         return resourceByMethodPath;
  259.     }
  260.     
  261.     public void popolaPorttypeOperationDaUnAltroASPC(AccordoServizioParteComune aspcDestinazione, AccordoServizioParteComune aspcSorgente, 
  262.             boolean aggiornaServiziAzioniEsistenti, boolean eliminaServiziAzioniNonPresentiNuovaInterfaccia,
  263.             List<IDPortType> portTypeEliminati, List<IDPortTypeAzione> operationEliminate) throws DriverRegistroServiziException{
  264.         String nomeMetodo = "popolaPorttypeOperationDaUnAltroASPC";
  265.         try {
  266.             IDAccordo idAccordo = null;
  267.             if(eliminaServiziAzioniNonPresentiNuovaInterfaccia) {
  268.                 idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromAccordo(aspcDestinazione);
  269.             }
  270.             
  271.             if(aspcSorgente.sizePortTypeList() > 0){
  272.                 for (PortType nuovoPortType : aspcSorgente.getPortTypeList()) {
  273.                     PortType vecchioPortType = null;
  274.                     for (PortType vecchioPortTypeTMP : aspcDestinazione.getPortTypeList()) {
  275.                         if(vecchioPortTypeTMP.getNome().equals(nuovoPortType.getNome())){
  276.                             vecchioPortType = vecchioPortTypeTMP;
  277.                             break;
  278.                         }
  279.                     }
  280.                     
  281.                     // non ho trovato l'elemento corrente nel aspc destinazione
  282.                     if(vecchioPortType == null){
  283.                         aspcDestinazione.addPortType(nuovoPortType);
  284.                     } else {
  285.                         if(aggiornaServiziAzioniEsistenti) {
  286.                             // ho trovato l'elemento, aggiorno i valori  rimpiazzando la risorsa
  287.                             PortType oldPT = null;
  288.                             for (int i = 0; i < aspcDestinazione.sizePortTypeList(); i++) {
  289.                                 if(aspcDestinazione.getPortType(i).getNome().equals(vecchioPortType.getNome())) {
  290.                                     oldPT = aspcDestinazione.removePortType(i);
  291.                                     break;
  292.                                 }
  293.                             }
  294.                             aspcDestinazione.addPortType(nuovoPortType);
  295.                             
  296.                             if(oldPT!=null) {
  297.                                 
  298.                                 // riporto eventuali properties
  299.                                 if(oldPT.sizeProtocolPropertyList()>0) {
  300.                                     for (int i = 0; i < oldPT.sizeProtocolPropertyList(); i++) {
  301.                                         nuovoPortType.addProtocolProperty(oldPT.getProtocolProperty(i));        
  302.                                     }
  303.                                 }
  304.                                 
  305.                                 // riporto funzionalità non gestite nel BasicArchive.setProtocolInfo
  306.                                 for (Operation vecchiaAzione : oldPT.getAzioneList()) {
  307.                                     
  308.                                     if(!CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO.equals(vecchiaAzione.getProfAzione()) && vecchiaAzione.sizeProtocolPropertyList()<=0 ) {
  309.                                         continue;
  310.                                     }
  311.                                                                             
  312.                                     Operation nuovaAzione = null;
  313.                                     for (Operation azCheck : nuovoPortType.getAzioneList()) {
  314.                                         if(azCheck.getNome().equals(vecchiaAzione.getNome())) {
  315.                                             nuovaAzione = azCheck;
  316.                                             break;
  317.                                         }
  318.                                     }
  319.                                     
  320.                                     if(nuovaAzione!=null && vecchiaAzione.sizeProtocolPropertyList()>0) {
  321.                                         
  322.                                         // riporto eventuali properties
  323.                                         for (int i = 0; i < vecchiaAzione.sizeProtocolPropertyList(); i++) {
  324.                                             nuovaAzione.addProtocolProperty(vecchiaAzione.getProtocolProperty(i));      
  325.                                         }
  326.                                                                                 
  327.                                     }
  328.                                     
  329.                                     if(nuovaAzione!=null && CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO.equals(vecchiaAzione.getProfAzione())) {
  330.                                         
  331.                                         boolean ridefinisci = false;
  332.                                         if(vecchiaAzione.getConfermaRicezione()!=null && org.openspcoop2.core.registry.constants.StatoFunzionalita.ABILITATO.equals(vecchiaAzione.getConfermaRicezione())) {
  333.                                             nuovaAzione.setConfermaRicezione(vecchiaAzione.getConfermaRicezione());
  334.                                             ridefinisci = true;
  335.                                         }
  336.                                         if(vecchiaAzione.getConsegnaInOrdine()!=null && org.openspcoop2.core.registry.constants.StatoFunzionalita.ABILITATO.equals(vecchiaAzione.getConsegnaInOrdine())) {
  337.                                             nuovaAzione.setConsegnaInOrdine(vecchiaAzione.getConsegnaInOrdine());
  338.                                             ridefinisci = true;
  339.                                         }
  340.                                         if(vecchiaAzione.getIdCollaborazione()!=null && org.openspcoop2.core.registry.constants.StatoFunzionalita.ABILITATO.equals(vecchiaAzione.getIdCollaborazione())) {
  341.                                             nuovaAzione.setIdCollaborazione(vecchiaAzione.getIdCollaborazione());
  342.                                             ridefinisci = true;
  343.                                         }
  344.                                         if(vecchiaAzione.getIdRiferimentoRichiesta()!=null && org.openspcoop2.core.registry.constants.StatoFunzionalita.ABILITATO.equals(vecchiaAzione.getIdRiferimentoRichiesta())) {
  345.                                             nuovaAzione.setIdRiferimentoRichiesta(vecchiaAzione.getIdRiferimentoRichiesta());
  346.                                             ridefinisci = true;
  347.                                         }
  348.                                         if(vecchiaAzione.getScadenza()!=null && !"".equals(vecchiaAzione.getScadenza())) {
  349.                                             nuovaAzione.setScadenza(vecchiaAzione.getScadenza());
  350.                                             ridefinisci = true;
  351.                                         }
  352.                                         // filtro duplicati gestito nel BasicArchive.setProtocolInfo
  353.                                         if(vecchiaAzione.getFiltroDuplicati()!=null &&
  354.                                             !vecchiaAzione.getFiltroDuplicati().equals(nuovaAzione.getFiltroDuplicati())) {
  355.                                             nuovaAzione.setFiltroDuplicati(vecchiaAzione.getFiltroDuplicati());
  356.                                             ridefinisci = true;
  357.                                         }
  358.                                         if(ridefinisci) {
  359.                                             nuovaAzione.setProfAzione(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO);
  360.                                             if(nuovaAzione.getProfiloCollaborazione()!=null) {
  361.                                                 nuovaAzione.setProfiloCollaborazione(nuovaAzione.getProfiloCollaborazione());
  362.                                             }
  363.                                             else if(nuovoPortType.getProfiloCollaborazione()!=null) {
  364.                                                 nuovaAzione.setProfiloCollaborazione(nuovoPortType.getProfiloCollaborazione());
  365.                                             }
  366.                                             else {
  367.                                                 nuovaAzione.setProfiloCollaborazione(aspcDestinazione.getProfiloCollaborazione());
  368.                                             }
  369.                                         }
  370.                                     }
  371.                                 }
  372.                             }
  373.                         
  374.                             // riporto le azioni presenti nel vecchio e non nel nuovo.
  375.                             if(nuovoPortType.sizeAzioneList() > 0){
  376.                                 for (Operation vecchiaAzione : vecchioPortType.getAzioneList()) {
  377.                                     boolean find = false;
  378.                                     for (Operation nuovaAzione : nuovoPortType.getAzioneList()) {
  379.                                         if(nuovaAzione.getNome().equals(vecchiaAzione.getNome())) {
  380.                                             find = true;
  381.                                             break;
  382.                                         }
  383.                                     }
  384.                                     if(!find) {
  385.                                         if(eliminaServiziAzioniNonPresentiNuovaInterfaccia) {
  386.                                             IDPortType idPortType = new IDPortType();
  387.                                             idPortType.setIdAccordo(idAccordo);
  388.                                             idPortType.setNome(vecchioPortType.getNome());
  389.                                             
  390.                                             IDPortTypeAzione idPortTypeAzione = new IDPortTypeAzione();
  391.                                             idPortTypeAzione.setIdPortType(idPortType);
  392.                                             idPortTypeAzione.setNome(vecchiaAzione.getNome());
  393.                                             operationEliminate.add(idPortTypeAzione);
  394.                                         }
  395.                                         else {
  396.                                             nuovoPortType.addAzione(vecchiaAzione);
  397.                                         }
  398.                                     }
  399.                                 }
  400.                             }
  401.                             else {
  402.                                 if(vecchioPortType.sizeAzioneList()>0) {
  403.                                     for (Operation op : vecchioPortType.getAzioneList()) {
  404.                                         if(eliminaServiziAzioniNonPresentiNuovaInterfaccia) {
  405.                                             IDPortType idPortType = new IDPortType();
  406.                                             idPortType.setIdAccordo(idAccordo);
  407.                                             idPortType.setNome(vecchioPortType.getNome());
  408.                                             
  409.                                             IDPortTypeAzione idPortTypeAzione = new IDPortTypeAzione();
  410.                                             idPortTypeAzione.setIdPortType(idPortType);
  411.                                             idPortTypeAzione.setNome(op.getNome());
  412.                                             operationEliminate.add(idPortTypeAzione);
  413.                                         }
  414.                                         else {
  415.                                             nuovoPortType.addAzione(op);
  416.                                         }
  417.                                     }
  418.                                 }
  419.                             }
  420.                         }
  421.                         else {
  422.                             // Aggiungo solo le azioni nuove
  423.                             if(nuovoPortType.sizeAzioneList() > 0){
  424.                                 for (Operation nuovaAzione : nuovoPortType.getAzioneList()) {
  425.                                     boolean find = false;
  426.                                     for (Operation vecchiaAzione : vecchioPortType.getAzioneList()) {
  427.                                         if(nuovaAzione.getNome().equals(vecchiaAzione.getNome())) {
  428.                                             find = true;
  429.                                             break;
  430.                                         }
  431.                                     }
  432.                                     if(!find) {
  433.                                         vecchioPortType.addAzione(nuovaAzione);
  434.                                     }
  435.                                 }
  436.                             }
  437.                         }
  438.                     }
  439.                 }
  440.             }
  441.             if(eliminaServiziAzioniNonPresentiNuovaInterfaccia) {
  442.                 
  443.                 // elimino port type non più presenti
  444.                 if(aspcDestinazione.sizePortTypeList() > 0){
  445.                     List<PortType> portTypeDaEliminare = new ArrayList<>();
  446.                     for (PortType oldPortType : aspcDestinazione.getPortTypeList()) {
  447.                         
  448.                         if(aspcSorgente.sizePortTypeList() > 0){
  449.                             boolean find = false;
  450.                             for (PortType nuovoPortType : aspcSorgente.getPortTypeList()) {
  451.                                 if(nuovoPortType.getNome().equals(oldPortType.getNome())){
  452.                                     find = true;
  453.                                     break;
  454.                                 }
  455.                             }
  456.                             if(!find) {
  457.                                 portTypeDaEliminare.add(oldPortType);
  458.                             }
  459.                         }
  460.                         
  461.                     }
  462.                     while(!portTypeDaEliminare.isEmpty()) {
  463.                         PortType ptDaEliminare = portTypeDaEliminare.remove(0);
  464.                         for (int i = 0; i < aspcDestinazione.sizePortTypeList(); i++) {
  465.                             if(aspcDestinazione.getPortType(i).getNome().equals(ptDaEliminare.getNome())) {
  466.                                 aspcDestinazione.removePortType(i);
  467.                                 
  468.                                 IDPortType idPortType = new IDPortType();
  469.                                 idPortType.setIdAccordo(idAccordo);
  470.                                 idPortType.setNome(ptDaEliminare.getNome());
  471.                                 portTypeEliminati.add(idPortType);
  472.                                 
  473.                                 break;
  474.                             }
  475.                         }
  476.                     }
  477.                 }
  478.                 
  479.                 // elimino azioni non più presenti
  480.                 if(aspcDestinazione.sizePortTypeList() > 0){
  481.                     for (PortType oldPortType : aspcDestinazione.getPortTypeList()) {
  482.                         
  483.                         List<Operation> operationDaEliminare = new ArrayList<Operation>();
  484.                         if(oldPortType.sizeAzioneList() > 0){
  485.                             for (Operation oldOperation : oldPortType.getAzioneList()) {
  486.                                 
  487.                                 // find operation in new
  488.                                 PortType newPortType = null;
  489.                                 for (PortType nuovoPortType : aspcSorgente.getPortTypeList()) {
  490.                                     if(nuovoPortType.getNome().equals(oldPortType.getNome())){
  491.                                         newPortType = nuovoPortType;
  492.                                         break;
  493.                                     }
  494.                                 }
  495.                                 boolean find = false;
  496.                                 if(newPortType!=null && newPortType.sizeAzioneList()>0) {
  497.                                     for (Operation nuovaAzione : newPortType.getAzioneList()) {
  498.                                         if(nuovaAzione.getNome().equals(oldOperation.getNome())) {
  499.                                             find = true;
  500.                                             break;
  501.                                         }
  502.                                     }
  503.                                 }
  504.                                 if(!find) {
  505.                                     operationDaEliminare.add(oldOperation);
  506.                                 }
  507.                             }
  508.                         }
  509.                         while(!operationDaEliminare.isEmpty()) {
  510.                             Operation opDaEliminare = operationDaEliminare.remove(0);
  511.                             for (int i = 0; i < oldPortType.sizeAzioneList(); i++) {
  512.                                 if(oldPortType.getAzione(i).getNome().equals(opDaEliminare.getNome())) {
  513.                                     oldPortType.removeAzione(i);
  514.                                     
  515.                                     IDPortType idPortType = new IDPortType();
  516.                                     idPortType.setIdAccordo(idAccordo);
  517.                                     idPortType.setNome(oldPortType.getNome());
  518.                                     
  519.                                     IDPortTypeAzione idPortTypeAzione = new IDPortTypeAzione();
  520.                                     idPortTypeAzione.setIdPortType(idPortType);
  521.                                     idPortTypeAzione.setNome(opDaEliminare.getNome());
  522.                                     operationEliminate.add(idPortTypeAzione);
  523.                                     
  524.                                     break;
  525.                                 }
  526.                             }
  527.                         }
  528.                     }
  529.                 }
  530.             }
  531.         }
  532.         catch (Exception e) {
  533.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  534.             throw e;
  535.         }
  536.     }
  537.     
  538.     private static final String WSDL_PREFIX = "WsdlTypes_";
  539.     private static final String COMPARE_ERROR = "Compare external failed: ";
  540.     
  541.     public void estraiSchemiFromWSDLTypesAsAllegati(AccordoServizioParteComune as, byte[] wsdl, String tipoWSDL, Map<String, byte[]> schemiAggiuntiInQuestaOperazione) throws Exception{
  542.                 
  543.         String nomeMetodo = "addSchemiFromWSDLTypesAsAllegati";
  544.         try {
  545.             
  546.             // Allegati
  547.             List<byte[]> schemiPresentiInternamenteTypes = new ArrayList<>();
  548.             List<String> nomiSchemiPresentiInternamenteTypes = new ArrayList<>();
  549.             
  550.             try{
  551.                 
  552.                 AbstractXMLUtils xmlUtils = MessageXMLUtils.DEFAULT; 
  553.                 XSDUtils xsdUtils = new XSDUtils(xmlUtils);
  554.                 WSDLUtilities wsdlUtilities = new WSDLUtilities(xmlUtils);
  555.                 
  556.                 ArchiviCore archiviCore = null;
  557.                 
  558.                 Document dConAllegati = xmlUtils.newDocument(wsdl);
  559.                 
  560.                 Map<String, String> declarationNamespacesWSDL = xmlUtils.getNamespaceDeclaration(dConAllegati.getDocumentElement());
  561.                 
  562.                 List<Node> schemi = wsdlUtilities.getSchemiXSD(dConAllegati);
  563.                 if(!schemi.isEmpty()){
  564.                     wsdlUtilities.removeSchemiIntoTypes(dConAllegati);
  565.                     
  566.                     for (int i = 0; i < schemi.size(); i++) {
  567.                         
  568.                         Node schema = schemi.get(i);
  569.                         
  570.                         // NOTA: Volendo si potrebbe utilizzare la solita gestione anche per schemi che hanno solo gli include
  571.                         //        Al momento dell'implementazione non avevo chiaro però se era utile avere tra gli XSD Collections (utilizzati per la validazione)
  572.                         //        Lo schema originale che contiene gli include (per cambi di namespace)
  573.                         //        Quindi ho preferito tenere l'originale schema con gli include tra gli schemi e qua importarlo.
  574.                         boolean schemaWithOnlyImport = xsdUtils.isSchemaWithOnlyImports(schema);
  575.                         if(schemaWithOnlyImport){
  576.                             // riaggiungo l'import
  577.                             wsdlUtilities.addSchemaIntoTypes(dConAllegati, schema);
  578.                             continue;
  579.                         }
  580.                         
  581.                         if(archiviCore==null)
  582.                             archiviCore = new ArchiviCore(this);
  583.                         
  584.                         String targetNamespace = xsdUtils.getTargetNamespace(schema);
  585.                         if(targetNamespace!=null){
  586.                                             
  587.                             if(declarationNamespacesWSDL!=null && declarationNamespacesWSDL.size()>0){
  588.                                 xmlUtils.addNamespaceDeclaration(declarationNamespacesWSDL, (Element) schema);
  589.                             }   
  590.                             
  591.                             String nomeSchema = null;
  592.                             if(schemiAggiuntiInQuestaOperazione!=null && schemiAggiuntiInQuestaOperazione.size()>0){
  593.                                 for (String nomeFile : schemiAggiuntiInQuestaOperazione.keySet()) {
  594.                                     byte[] content = schemiAggiuntiInQuestaOperazione.get(nomeFile);
  595.                                     // check se si tratta di questo documento
  596.                                     try{
  597.                                         String tmp = checkXsdAlreadyExists(xmlUtils, content, nomeFile, schema);
  598.                                         if(tmp!=null){
  599.                                             nomeSchema = tmp;
  600.                                             break;
  601.                                         }
  602.                                     }catch(Exception t){
  603.                                         logError(COMPARE_ERROR+t.getMessage(),t);
  604.                                     }
  605.                                 }
  606.                             }
  607.                             if(nomeSchema==null &&
  608.                                 as.getByteWsdlDefinitorio()!=null){
  609.                                 // check se si tratta di questo documento
  610.                                 try{
  611.                                     String tmp = checkXsdAlreadyExists(xmlUtils, as.getByteWsdlDefinitorio(), 
  612.                                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_INTERFACCIA_DEFINITORIA, schema);
  613.                                     if(tmp!=null){
  614.                                         nomeSchema = tmp;
  615.                                     }
  616.                                 }catch(Exception t){
  617.                                     logError(COMPARE_ERROR+t.getMessage(),t);
  618.                                 }
  619.                             }
  620.                             if(nomeSchema==null &&
  621.                                 as.sizeAllegatoList()>0){
  622.                                 for (Documento docTMP : as.getAllegatoList()) {
  623.                                     String nomeDocumento = docTMP.getFile();
  624.                                     try{
  625.                                         Documento doc = archiviCore.getDocumento(docTMP.getId(),true);
  626.                                         if(xsdUtils.isXSDSchema(doc.getByteContenuto())){
  627.                                             // check se si tratta di questo documento
  628.                                             String tmp = checkXsdAlreadyExists(xmlUtils, doc.getByteContenuto(), nomeDocumento, schema);
  629.                                             if(tmp!=null){
  630.                                                 nomeSchema = tmp;
  631.                                                 break;
  632.                                             }
  633.                                         }
  634.                                     }catch(Exception t){
  635.                                         logError(COMPARE_ERROR+t.getMessage(),t);
  636.                                     }
  637.                                 }
  638.                             }
  639.                             if(nomeSchema==null &&
  640.                                 as.sizeSpecificaSemiformaleList()>0){
  641.                                 for (Documento docTMP : as.getSpecificaSemiformaleList()) {
  642.                                     String nomeDocumento = docTMP.getFile();
  643.                                     try{
  644.                                         Documento doc = archiviCore.getDocumento(docTMP.getId(),true);
  645.                                         if(xsdUtils.isXSDSchema(doc.getByteContenuto())){
  646.                                             // check se si tratta di questo documento
  647.                                             String tmp = checkXsdAlreadyExists(xmlUtils, doc.getByteContenuto(), nomeDocumento, schema);
  648.                                             if(tmp!=null){
  649.                                                 nomeSchema = tmp;
  650.                                                 break;
  651.                                             }
  652.                                         }
  653.                                     }catch(Exception t){
  654.                                         logError(COMPARE_ERROR+t.getMessage(),t);
  655.                                     }
  656.                                 }
  657.                             }
  658.                             
  659.                             boolean alreadyExistsSchema = (nomeSchema!=null);
  660.                             
  661.                             if(nomeSchema==null){
  662.                                 // build new nome
  663.                                 int index = 1;
  664.                                 nomeSchema = WSDL_PREFIX+(index)+".xsd";
  665.                                 while(index<10000){ // 10000 allegati??
  666.                                     boolean found = false;
  667.                                     if(nomiSchemiPresentiInternamenteTypes.contains(nomeSchema)){
  668.                                         found = true;
  669.                                     }
  670.                                     else{
  671.                                         for (Documento vecchioAllegatoTMP : as.getAllegatoList()) {
  672.                                             if(vecchioAllegatoTMP.getFile().startsWith(WSDL_PREFIX) && vecchioAllegatoTMP.getFile().equals(nomeSchema)){
  673.                                                 found = true;
  674.                                                 break;
  675.                                             }
  676.                                         }
  677.                                     }
  678.                                     if(!found){
  679.                                         break;
  680.                                     }
  681.                                     index++;
  682.                                     nomeSchema = WSDL_PREFIX+(index)+".xsd";
  683.                                 }
  684.                             }
  685.                             
  686.                             wsdlUtilities.addImportSchemaIntoTypes(dConAllegati, targetNamespace, nomeSchema);
  687.                             
  688.                             if(!alreadyExistsSchema){
  689.                                 
  690.                                 nomiSchemiPresentiInternamenteTypes.add(nomeSchema);
  691.                                 schemiPresentiInternamenteTypes.add(xmlUtils.toByteArray(schema));

  693.                             }
  694.                                                         
  695.                         }
  696.                         else{
  697.                             try{
  698.                                 logError("Presente schema senza targetNamespace? (Viene usato l'originale) ["+xmlUtils.toString(schema)+"]");
  699.                             }catch(Exception t){
  700.                                 logError("Presente schema senza targetNamespace? (Viene usato l'originale)");
  701.                             }
  702.                             wsdlUtilities.addSchemaIntoTypes(dConAllegati, schema);
  703.                         }
  704.                         
  705.                     }
  706.                     
  707.                     // Aggiorno WSDL
  708.                     
  709.                     byte [] wsdlPulito = xmlUtils.toByteArray(dConAllegati);
  710.                     
  711.                     if(AccordiServizioParteComuneCostanti.TIPO_WSDL_CONCETTUALE.equals(tipoWSDL)){
  712.                         as.setByteWsdlConcettuale(wsdlPulito);
  713.                     }
  714.                     else if(AccordiServizioParteComuneCostanti.TIPO_WSDL_EROGATORE.equals(tipoWSDL)){
  715.                         as.setByteWsdlLogicoErogatore(wsdlPulito);
  716.                     }
  717.                     else if(AccordiServizioParteComuneCostanti.TIPO_WSDL_FRUITORE.equals(tipoWSDL)){
  718.                         as.setByteWsdlLogicoFruitore(wsdlPulito);
  719.                     }
  720.                 }
  721.                 
  722.             }catch(Exception t){
  723.                 logError("Errore durante la lettura degli schemi presenti all'interno del wsdl: "+t.getMessage(),t);
  724.             }
  725.             
  726.             if(!nomiSchemiPresentiInternamenteTypes.isEmpty()){
  727.                 int i = 0;
  728.                 for (String nomeNuovoAllegato : nomiSchemiPresentiInternamenteTypes) {
  729.                     
  730.                     try{
  731.                     
  732.                         if(schemiAggiuntiInQuestaOperazione!=null){
  733.                             schemiAggiuntiInQuestaOperazione.put(nomeNuovoAllegato, schemiPresentiInternamenteTypes.get(i));
  734.                         }
  735.                         
  736.                         Documento vecchioAllegato = null;
  737.                         for (Documento vecchioAllegatoTMP : as.getAllegatoList()) {
  738.                             if(vecchioAllegatoTMP.getFile().equals(nomeNuovoAllegato)){
  739.                                 vecchioAllegato = vecchioAllegatoTMP;
  740.                                 break;
  741.                             }
  742.                         }
  743.                         
  744.                         // non ho trovato l'elemento corrente nel aspc destinazione
  745.                         if(vecchioAllegato == null){
  746.                             Documento allegato = new Documento();
  747.                             allegato.setRuolo(RuoliDocumento.allegato.toString());
  748.                             allegato.setByteContenuto(schemiPresentiInternamenteTypes.get(i));
  749.                             allegato.setFile(nomeNuovoAllegato);
  750.                             allegato.setTipo("xsd");
  751.                             allegato.setIdProprietarioDocumento(as.getId());
  752.                             as.addAllegato(allegato);
  753.                         } else {
  754.                             
  755.                             // CASO CHE NON DOVREBBE OCCORRERE MAI VISTO LA LOGICA CON XMLDIFF
  756.                             
  757.                             // ho trovato l'elemento, aggiorno i valori 
  758.                             vecchioAllegato.setByteContenuto(schemiPresentiInternamenteTypes.get(i));
  759.                         }
  760.                         
  761.                         i++;
  762.                         
  763.                     }catch(Exception t){
  764.                         logError("Errore durante l'aggiornamento dello schema ["+nomeNuovoAllegato+"] estratto dal wsdl: "+t.getMessage(),t);
  765.                     }
  766.                 }
  767.             }
  768.             
  769.         }
  770.         catch (Exception e) {
  771.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  772.             throw e;
  773.         }
  774.     }
  775.     
  776.     private String checkXsdAlreadyExists(AbstractXMLUtils xmlUtils, byte[] xsdEsistenteContenuto, String xsdEsistenteNome,  Node schema){
  777.         // check se si tratta di questo documento
  778.         try{
  779.             Node n = xmlUtils.newElement(xsdEsistenteContenuto);
  780.             XMLDiff xmlDiff = new XMLDiff(OpenSPCoop2MessageFactory.getDefaultMessageFactory());
  781.             /**System.out.println("["+vecchioAllegatoTMP.getFile()+"] N:"+xmlUtils.toString(n));
  782.             System.out.println("["+vecchioAllegatoTMP.getFile()+"] Schema:"+xmlUtils.toString(schema));*/
  783.             // NOTA: la ricostruzione in N2 è necessaria, poichè schema si porta dietro il definition wsdl (non ho capito perchè)
  784.             Node n2 = xmlUtils.newElement(xmlUtils.toString(schema).getBytes());
  785.             /**System.out.println("["+vecchioAllegatoTMP.getFile()+"] N2:"+xmlUtils.toString(n2));*/
  786.             if(xmlDiff.diff(n, n2)){
  787.                 return xsdEsistenteNome;
  788.                 /**System.out.println("["+vecchioAllegatoTMP.getFile()+"] TROVATO UGUALE ["+nomeSchema+"]");*/
  789.             }
  790.             /**else{
  791.                 System.out.println("["+vecchioAllegatoTMP.getFile()+"] TROVATO NON UGUALE: \n"+xmlDiff.getDifferenceDetails());
  792.             }*/
  793.             return null;
  794.         }catch(Exception t){
  795.             logError("Compare failed: "+t.getMessage(),t);
  796.             return null;
  797.         }
  798.     }
  799.     
  800.     public String readEndpoint(AccordoServizioParteComuneSintetico as, String portTypeParam, String servcorr, 
  801.             BinaryParameter wsdlimpler, BinaryParameter wsdlimplfru) {
  802.         if(as==null) {
  803.             return null;
  804.         }
  805.         String portType = portTypeParam;
  806.         if("".equals(portTypeParam)) {
  807.             portType = null;
  808.         }
  809.         try {
  810.             FormatoSpecifica formato = as.getFormatoSpecifica();
  811.             String urlSuggerita = null;
  812.             switch (formato) {
  813.             case OPEN_API_3:
  814.             case SWAGGER_2:
  815.             case WADL:
  816.                 if(as.getByteWsdlConcettuale()!=null) {
  817.                     IApiReader apiReader = null;
  818.                     if(FormatoSpecifica.OPEN_API_3.equals(formato)) {
  819.                         apiReader = ApiFactory.newApiReader(ApiFormats.OPEN_API_3);
  820.                     }
  821.                     else if(FormatoSpecifica.SWAGGER_2.equals(formato)) {
  822.                         apiReader = ApiFactory.newApiReader(ApiFormats.SWAGGER_2);
  823.                     }
  824.                     else {
  825.                         apiReader = ApiFactory.newApiReader(ApiFormats.WADL);
  826.                     }
  827.                     ApiReaderConfig config = new ApiReaderConfig();
  828.                     config.setProcessInclude(false);
  829.                     config.setProcessInlineSchema(false);
  830.                     apiReader.init(LoggerWrapperFactory.getLogger(AccordiServizioParteSpecificaAdd.class), as.getByteWsdlConcettuale(), config);
  831.                     Api api = apiReader.read();
  832.                     if(api.getBaseURL()!=null) {
  833.                         urlSuggerita = api.getBaseURL().toString();
  834.                     }
  835.                 }
  836.                 break;
  837.             case WSDL_11:
  838.                 byte [] wsdl = null;
  839.                 if(ServletUtils.isCheckBoxEnabled(servcorr)) {
  840.                     if(wsdlimplfru!=null && wsdlimplfru.getValue()!=null) {
  841.                         wsdl = wsdlimplfru.getValue();
  842.                     }
  843.                     else {
  844.                         wsdl = as.getByteWsdlLogicoFruitore();
  845.                     }
  846.                 }
  847.                 else{
  848.                     if(wsdlimpler!=null && wsdlimpler.getValue()!=null) {
  849.                         wsdl = wsdlimpler.getValue();
  850.                     }
  851.                     else {
  852.                         wsdl = as.getByteWsdlLogicoErogatore();
  853.                     }
  854.                 }
  855.                 if(wsdl==null) {
  856.                     wsdl = as.getByteWsdlConcettuale();
  857.                 }
  858.                 if(wsdl!=null) {
  859.                     WSDLUtilities utilities = new WSDLUtilities(org.openspcoop2.utils.xml.XMLUtils.getInstance());
  860.                     urlSuggerita = utilities.getServiceEndpoint(wsdl, portType);
  861.                 }
  862.                 break;
  863.             }
  864.             return urlSuggerita;
  865.         }catch(Throwable t){
  866.             if( portType!=null || !FormatoSpecifica.WSDL_11.equals(as.getFormatoSpecifica()) ) {
  867.                 log.error("Read endpoint from interface failed: "+t.getMessage(),t);
  868.             }
  869.             else {
  870.                 log.debug("Read endpoint from interface failed: "+t.getMessage(),t);
  871.             }
  872.             return null;
  873.         }
  874.     }
  875. }
Created with JaCoCo 0.8.8.202204050719