XMLDataConverterMainProcessor.java

/*
 * GovWay - A customizable API Gateway 
 * https://govway.org
 * 
 * Copyright (c) 2005-2024 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.core.config.driver.utils;

import java.io.File;
import java.io.FileInputStream;
import java.net.URL;
import java.sql.Connection;
import java.sql.DriverManager;

import org.apache.logging.log4j.Level;
import org.openspcoop2.core.config.AccessoConfigurazionePdD;
import org.openspcoop2.core.config.driver.ExtendedInfoManager;
import org.openspcoop2.utils.LoggerWrapperFactory;
import org.openspcoop2.utils.Semaphore;
import org.openspcoop2.utils.Utilities;
import org.openspcoop2.utils.resources.FileSystemUtilities;
import org.openspcoop2.utils.resources.Loader;
import org.slf4j.Logger;

/**
 * Inizializza una configurazione
 * 
 * @author Andrea Poli (apoli@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */

public class XMLDataConverterMainProcessor {


	public static void main(String[] argoments) throws Exception {

		
		                               
		if (argoments.length  < 9) {
			String errorMsg = "ERROR, Usage:  java XMLDataConverterMainProcessor sorgenteXML tipoConfigurazioneCRUD proprietaConfigurazioneCRUD reset isGestioneConfigurazione tipoConversione gestioneSoggetti gestioneMappingErogazioneFruizione protocolloDefault [Logger]";
			System.err.println(errorMsg);
			throw new Exception(errorMsg);
		}

		String args_sorgenteXML = argoments[0].trim();
		String args_tipoConfigurazioneCRUD = argoments[1].trim();
		String args_proprietaConfigurazioneCRUD = argoments[2].trim();
		String args_reset = argoments[3].trim();
		String args_isGestioneConfigurazione = argoments[4].trim();
		String args_tipoConversione = argoments[5].trim();
		String args_gestioneSoggetti = argoments[6].trim();
		String args_gestioneMappingErogazioneFruizione = argoments[7].trim();
		String args_protocolloDefault = argoments[8].trim();
		String args_logger = null;
		if(argoments.length>9){
			args_logger = argoments[9].trim();
		}
		
		// Inizializzo logger
		String loggerValue = null;
		try{
			if(args_logger!=null){
				LoggerWrapperFactory.setLogConfiguration(args_logger);
			}else{
				URL url = XMLDataConverterMainProcessor.class.getResource("/xml2backend.log4j2.properties");
				if(url!=null){
					LoggerWrapperFactory.setLogConfiguration(url);
				}
				else{
					File logFile = FileSystemUtilities.createTempFile("testXMLDataConverterConfigurazione_", ".log");
					System.out.println("LogMessages write in "+logFile.getAbsolutePath());
					LoggerWrapperFactory.setDefaultLogConfiguration(Level.ALL, false, null, logFile, "%p <%d{dd-MM-yyyy HH:mm:ss}> %C.%M(%L): %m %n %n");
				}
			}
		}catch(Exception e) {
			String errorMsg = "Errore durante il caricamento del file di log loggerValue["+loggerValue+"] : "+e.getMessage();
			System.err.println(errorMsg);
			System.out.println("Args.length: "+argoments.length);
			for (int i = 0; i < argoments.length; i++) {
				System.out.println("Arg["+i+"]=["+argoments[i]+"]");
			}
			throw new Exception(errorMsg,e);
		}	
		Logger log = LoggerWrapperFactory.getLogger("gestoreDatiConfigurazione");
		
		java.util.Properties reader = new java.util.Properties();
		try{
			try(FileInputStream fin = new FileInputStream(args_proprietaConfigurazioneCRUD)){
				reader.load(fin);
			}
		}catch(java.io.IOException e) {
			String errorMsg = "Errore durante il caricamento del file di properties ["+args_proprietaConfigurazioneCRUD+"] : "+e.getMessage();
			log.error(errorMsg,e);
			throw new Exception(errorMsg,e);
		}

		// ProtocolloDefault
		String protocolloDefault = args_protocolloDefault;
		
		// Reset
		boolean reset = Boolean.parseBoolean(args_reset);
		
		// GestioneSoggetti
		boolean gestioneSoggetti =  Boolean.parseBoolean(args_gestioneSoggetti);
		
		// isGestioneConfigurazione
		boolean isGestioneConfigurazione = Boolean.parseBoolean(args_isGestioneConfigurazione);
		
		// GestioneMappingErogazioneFruizione
		boolean gestioneMappingErogazioneFruizione =  Boolean.parseBoolean(args_gestioneMappingErogazioneFruizione);
		
		// Raccolta proprieta'
		AccessoConfigurazionePdD acCRUD = new AccessoConfigurazionePdD();
		String superUser = null;
		boolean connectionDB = false;
		String connection = null;
		String username = null;
		String password = null;
		String driver =  null;
		String tipoDatabase = null;
		boolean condivisioneDBRegservPddValue = false;
		try{
			acCRUD.setTipo(args_tipoConfigurazioneCRUD);
						
			superUser = reader.getProperty("openspcoop2.superuser");
			if(superUser!=null)
				superUser = superUser.trim();
			
			if("db".equals(args_tipoConfigurazioneCRUD)){
				// Database
				tipoDatabase = reader.getProperty("openspcoop2.configurazione.db.tipo");
				if(tipoDatabase==null){
					throw new Exception("Non e' stato definito il tipo di database");
				}else{
					tipoDatabase = tipoDatabase.trim();
				}
				
				String condivisioneDBRegservPdd = reader.getProperty("openspcoop2.configurazione.db.condivisioneDBRegserv");
				try{
					condivisioneDBRegservPddValue = Boolean.parseBoolean(condivisioneDBRegservPdd.trim());
				}catch(Exception e){
					throw new Exception("Non e' stato definita o e' definita non correttamente la proprieta' [openspcoop2.configurazione.db.condivisioneDBRegserv]: "+e.getMessage());
				}
				
				String dataSource = reader.getProperty("openspcoop2.configurazione.db.dataSource");
				if(dataSource!=null){
					dataSource = dataSource.trim();
					java.util.Properties context = Utilities.readProperties("openspcoop2.configurazione.db.context.",reader);
					acCRUD.setLocation(dataSource);
					acCRUD.setContext(context);
					acCRUD.setTipoDatabase(tipoDatabase);
				}else{
					connectionDB = true;
					connection = reader.getProperty("openspcoop2.configurazione.db.url");
					if(connection==null){
						throw new Exception("Non e' stata definita una destinazione ne attraverso un datasource, ne attraverso una connessione diretta");
					}
					connection = connection.trim();
					driver = reader.getProperty("openspcoop2.configurazione.db.driver");
					if(driver==null){
						throw new Exception("Connessione diretta: non e' stato definito il Driver");
					}
					driver = driver.trim();
					username = reader.getProperty("openspcoop2.configurazione.db.user");
					password = reader.getProperty("openspcoop2.configurazione.db.password");
					if(username!=null){
						username = username.trim();
					}
					if(password!=null){
						password = password.trim();
					}
				}
			}

		}catch(Exception e) {
			String errorMsg = "Errore durante la lettura del file di properties ["+args_proprietaConfigurazioneCRUD+"] : "+e.getMessage();
			log.error(errorMsg,e);
			throw new Exception(errorMsg,e);
		}

		try{
			ExtendedInfoManager.initialize(new Loader(XMLDataConverterMainProcessor.class.getClassLoader()), null, null, null);
		}catch(Exception e){
			log.error("Inizializzazione [ExtendedInfoManager] fallita",e);
			return;
		}
		
		Connection connectionSQL = null;
		try{
			// XMLDataConverter
			File fSorgente = new File(args_sorgenteXML);
			if(connectionDB){	
				Loader.getInstance().newInstance(driver);
				if(username!=null && password!=null){
					connectionSQL = DriverManager.getConnection(connection,username,password);
				}else{
					connectionSQL = DriverManager.getConnection(connection);
				}
			}
			
			XMLDataConverterMainProcessor.letturaSorgenti(fSorgente, connectionDB, connectionSQL, tipoDatabase, log, acCRUD, 
					condivisioneDBRegservPddValue, superUser,protocolloDefault, args_tipoConversione, isGestioneConfigurazione, reset, gestioneSoggetti, gestioneMappingErogazioneFruizione);
			
		}catch(Exception e){
			String errorMsg = "Errore durante la conversione XML dei dati: "+e.getMessage(); 
			log.error(errorMsg,e);
			throw new Exception(errorMsg,e);
		}finally{
			try{
				if(connectionSQL!=null)
					connectionSQL.close();
			}catch(Exception e){
				// close
			}
		}
	}
	
	
	private static Semaphore semaphoreResetEffettuata = new Semaphore("TestXMLDataConverterConfigReset");
	private static Boolean resetEffettuata = false;
	private static boolean reset(boolean b){
		if(b){
			// Se si desidera la reset, controllo se e' gia stata effettuata
			semaphoreResetEffettuata.acquireThrowRuntime("reset");
			try {
				if(XMLDataConverterMainProcessor.resetEffettuata==false){
					XMLDataConverterMainProcessor.resetEffettuata=true;
					return true;
				}
				else{
					return false;
				}
			}finally {
				semaphoreResetEffettuata.release("reset");
			}
		}
		return false;
	}
	
	
	private static void letturaSorgenti(File fSorgente,boolean connectionDB,Connection connectionSQL,
			String tipoDatabase,Logger log,AccessoConfigurazionePdD acCRUD,
			boolean condivisioneDBRegservPddValue,String superUser,String protocolloDefault,
			String tipoConversione, boolean isGestioneConfigurazione,boolean reset,boolean gestioneSoggetti,boolean gestioneMappingErogazioneFruizione) throws Exception{
		if(fSorgente.isFile()){
			if(fSorgente.canRead()==false){
				throw new Exception("Sorgente XML ["+fSorgente.getAbsolutePath()+"] non accessibile in lettura");
			}
			if(fSorgente.getName().endsWith(".xml")){
				// Per non convertire i wsdl e i xml
				XMLDataConverterMainProcessor.converti(fSorgente, connectionDB, connectionSQL, tipoDatabase, log, acCRUD, 
						condivisioneDBRegservPddValue, superUser,protocolloDefault, tipoConversione, isGestioneConfigurazione, reset, gestioneSoggetti,gestioneMappingErogazioneFruizione);
			}
			else{
				log.debug("File ["+fSorgente.getAbsolutePath()+"] ignorato. Non possiede l'estensione .xml");
			}
		}
		else if(fSorgente.isDirectory()){
			
			if(fSorgente.canRead()==false){
				throw new Exception("Directory contenente gli XML ["+fSorgente.getAbsolutePath()+"] non accessibile in lettura");
			}
			
			File [] f = fSorgente.listFiles();
			if(f==null || f.length<=0){
				throw new Exception("Directory ["+fSorgente.getAbsolutePath()+"] non contiene XML");
			}
			for(int i=0; i<f.length; i++){
			
				XMLDataConverterMainProcessor.letturaSorgenti(f[i], connectionDB, connectionSQL, tipoDatabase, log, acCRUD, 
						condivisioneDBRegservPddValue, superUser,protocolloDefault, tipoConversione, isGestioneConfigurazione, reset, gestioneSoggetti,gestioneMappingErogazioneFruizione);
				
			}
		}
	}
	
	
	private static void converti(File f,boolean connectionDB,Connection connectionSQL,
			String tipoDatabase,Logger log,AccessoConfigurazionePdD acCRUD,
			boolean condivisioneDBRegservPddValue,String superUser,String protocolloDefault,
			String tipoConversione, boolean isGestioneConfigurazione,boolean reset,boolean gestioneSoggetti,boolean gestioneMappingErogazioneFruizione) throws Exception{
		// XMLDataConverter
		XMLDataConverter dataConverter = null;
		Logger logDriver = null;
		if(connectionDB){		
			dataConverter = new XMLDataConverter(f,connectionSQL,tipoDatabase,
					isGestioneConfigurazione,condivisioneDBRegservPddValue,superUser,protocolloDefault,
					log,logDriver);
		}else{
			dataConverter = new XMLDataConverter(f,acCRUD,
					isGestioneConfigurazione,condivisioneDBRegservPddValue,superUser,protocolloDefault,
					log,logDriver);
		}
		
		if("insertUpdate".equals(tipoConversione)){
			log.info("Inizio conversione...");
			dataConverter.convertXML(XMLDataConverterMainProcessor.reset(reset),gestioneSoggetti,gestioneMappingErogazioneFruizione);
			log.info("Conversione terminata.");
		}
		else if("delete".equals(tipoConversione)){
			log.info("Inizio conversione...");
			dataConverter.delete(gestioneSoggetti,gestioneMappingErogazioneFruizione);
			log.info("Conversione terminata.");
		}else{
			throw new Exception("Valore opzione 'tipoConversioneConfigurazione' non gestito (valori possibili insertUpdate/delete): "+tipoConversione);
		}
	}
}