ArchiveValidator.java

/*
 * GovWay - A customizable API Gateway 
 * https://govway.org
 * 
 * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3, as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

package org.openspcoop2.protocol.engine.archive;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.openspcoop2.core.id.IDSoggetto;
import org.openspcoop2.core.registry.AccordoServizioParteComune;
import org.openspcoop2.core.registry.driver.IDAccordoFactory;
import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
import org.openspcoop2.protocol.sdk.IProtocolFactory;
import org.openspcoop2.protocol.sdk.archive.Archive;
import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
import org.openspcoop2.utils.resources.MapReader;

/**
 *  ArchiveValidator
 *
 * @author Poli Andrea (apoli@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */
public class ArchiveValidator {

	
	private IRegistryReader registryReader;
	
	public ArchiveValidator(IRegistryReader registryReader){
		this.registryReader = registryReader;
	}
	
	
	
	public void validateArchive(Archive archive, String protocolloEffettivo, 
			boolean validazioneDocumenti, ImportInformationMissingCollection importInformationMissingCollection, 
			String userLogin, boolean checkCorrelazioneAsincrona, boolean delete) throws Exception,ImportInformationMissingException{
		try{
			
			IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocolloEffettivo);
			
			validateAndFillImportInformationMissing(archive, protocolFactory, 
					importInformationMissingCollection, validazioneDocumenti, userLogin, 
					checkCorrelazioneAsincrona, delete);
							
		}catch(ImportInformationMissingException e){
			throw e;
		}catch(Exception e){
			throw e;
		}
	}
	
	private void validateAndFillImportInformationMissing(Archive archive,IProtocolFactory<?> protocolFactory, 
			ImportInformationMissingCollection importInformationMissingCollection, boolean validazioneDocumenti, String userLogin, 
			boolean checkCorrelazioneAsincrona, boolean delete) throws Exception,ImportInformationMissingException{
		
		ImporterInformationMissingUtils importerInformationMissingUtils = 
				new ImporterInformationMissingUtils(importInformationMissingCollection, this.registryReader, validazioneDocumenti, protocolFactory, userLogin, archive);
		
		// Soggetto Default
		Map<String, IDSoggetto> mapIdSoggettoDefault = new HashMap<>();
		Map<String, Boolean> mapAPIconReferente = new HashMap<>();
		ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance();
		if(protocolFactoryManager==null) {
			throw new Exception("ProtocolFactoryManager not initialized");
		}
		Enumeration<String> pEnum = protocolFactoryManager.getProtocolFactories().keys();
		if(pEnum!=null) {
			while (pEnum.hasMoreElements()) {
				String protocollo = (String) pEnum.nextElement();
				
				MapReader<String, String> mapTipoSoggettoDefault = protocolFactoryManager.getDefaultOrganizationTypes();
				if(mapTipoSoggettoDefault==null || mapTipoSoggettoDefault.size()<=0) {
					throw new Exception("TipiSoggetto di default non trovato per il protocollo '"+protocollo+"'");
				}
				
				String tipoSoggettoDefault = mapTipoSoggettoDefault.get(protocollo);
				if(tipoSoggettoDefault==null) {
					throw new Exception("TipoSoggetto di default non trovato per il protocollo '"+protocollo+"'");
				}
				
				IDSoggetto soggettoDefaultProtocollo = this.registryReader.getIdSoggettoDefault(tipoSoggettoDefault);
				if(soggettoDefaultProtocollo==null) {
					throw new Exception("IDSoggetto di default non trovato per il protocollo '"+protocollo+"'");
				}
				mapIdSoggettoDefault.put(protocollo, soggettoDefaultProtocollo);
								
				IProtocolFactory<?> pf = protocolFactoryManager.getProtocolFactoryByName(protocollo);
				boolean supportoReferente = false;
				if(pf!=null) {
					supportoReferente = pf.createProtocolConfiguration().isSupportoSoggettoReferenteAccordiParteComune();
				}
				mapAPIconReferente.put(protocollo, supportoReferente);
			}
		}
		
		
		// ArchiveInformationMissing
		if(archive.getInformationMissing()!=null){
			importerInformationMissingUtils.validateAndFillInformationMissing(archive.getInformationMissing(),delete);
			
			// Templates Names
//			ImporterInformationMissingSetter.replaceTemplatesNames(archive);
			// NO!! Senno tutti i riferimenti con EMPTY saltano!!!! Va fatto per ultimo.
		}
			
		// ServiziApplicativi
		for (int i = 0; i < archive.getServiziApplicativi().size(); i++) {
			importerInformationMissingUtils.validateAndFillServizioApplicativo(archive.getServiziApplicativi().get(i));
		}
		
		// PorteDelegate
		for (int i = 0; i < archive.getPorteDelegate().size(); i++) {
			importerInformationMissingUtils.validateAndFillPortaDelegata(archive.getPorteDelegate().get(i));
		}
		
		// PorteApplicative
		for (int i = 0; i < archive.getPorteApplicative().size(); i++) {
			importerInformationMissingUtils.validateAndFillPortaApplicativa(archive.getPorteApplicative().get(i));
		}
		
		// Accordi di Cooperazione
		for (int i = 0; i < archive.getAccordiCooperazione().size(); i++) {
			importerInformationMissingUtils.validateAndFillAccordoCooperazione(archive.getAccordiCooperazione().get(i));
		}
				
		// Accordi di Servizio Parte Comune 
		for (int i = 0; i < archive.getAccordiServizioParteComune().size(); i++) {
			importerInformationMissingUtils.validateAndFillAccordoServizioParteComune(archive.getAccordiServizioParteComune().get(i),
					checkCorrelazioneAsincrona);
		}
		
		// Accordi di Servizio Parte Specifica 
		// Divisione tra parte specifica "normale" e "composta".
		// In particolare non si prendono tutti i composti, ma solo quelli che richiedono prima il caricamento dell'accordo di servizio composto presente in questo archivio.
		List<ArchiveAccordoServizioParteSpecifica> listServiziImplementanoAccordiServizioCompostoPresentiArchivio = new ArrayList<ArchiveAccordoServizioParteSpecifica>();
		for (int i = 0; i < archive.getAccordiServizioParteSpecifica().size(); i++) {
			ArchiveAccordoServizioParteSpecifica archiveServizio = archive.getAccordiServizioParteSpecifica().get(i);
			String uriAccordoServizioParteComune = archiveServizio.getAccordoServizioParteSpecifica().getAccordoServizioParteComune();
			boolean found = false;
			for (int j = 0; j < archive.getAccordiServizioComposto().size(); j++) {
				AccordoServizioParteComune as = archive.getAccordiServizioComposto().get(j).getAccordoServizioParteComune();
				String uri = IDAccordoFactory.getInstance().getUriFromAccordo(as);
				if(uriAccordoServizioParteComune.equals(uri)){
					found = true;
					listServiziImplementanoAccordiServizioCompostoPresentiArchivio.add(archiveServizio);
					break;
				}
			}
			if(!found) {
				importerInformationMissingUtils.validateAndFillAccordoServizioParteSpecifica(archive.getAccordiServizioParteSpecifica().get(i),
						mapIdSoggettoDefault,
						mapAPIconReferente);
			}
		}

		// Accordi di Servizio Composti
		for (int i = 0; i < archive.getAccordiServizioComposto().size(); i++) {
			importerInformationMissingUtils.validateAndFillAccordoServizioParteComune(archive.getAccordiServizioComposto().get(i),
					checkCorrelazioneAsincrona);
		}
		
		// Accordi di Servizio Parte Specifica Composti
		for (ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica : listServiziImplementanoAccordiServizioCompostoPresentiArchivio) {
			importerInformationMissingUtils.validateAndFillAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica,
					mapIdSoggettoDefault,
					mapAPIconReferente);
		}
		
		// Fruizioni
		for (int i = 0; i < archive.getAccordiFruitori().size(); i++) {
			importerInformationMissingUtils.validateAndFillFruitore(archive.getAccordiFruitori().get(i));
		}
			
		// Templates Names
		ImporterInformationMissingSetter.replaceTemplatesNames(archive, this.registryReader);
	}
	
}