OKW_Properties.java

package okw;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
 
import java.util.regex.Pattern;
import okw.exceptions.OKWFileDoesNotExistsException;
import okw.log.Logger_Sngltn;
import okw.parser.Parser;
 
import org.apache.commons.lang3.StringUtils;
import org.stringtemplate.v4.ST;
 
public class OKW_Properties extends Properties
{
    private static OKW_Properties Instance;
    
    String PropPath = "";
    String PropPathWin = "";
    
    private static Logger_Sngltn Log = Logger_Sngltn.getInstance();
    
 
    protected ArrayList<String> CoreProperties = new ArrayList<String>();
    
 
    protected ArrayList<String> ResoursesProperties = new ArrayList<String>();
    
 
    protected ArrayList<String> FileProperties = new ArrayList<String>();
 
    private static final long serialVersionUID = -6936118958227023483L;
 
    public static OKW_Properties getInstance()
    //throws XPathExpressionException, JAXBException, ParserConfigurationException, SAXException, IOException
    {
        // Lazy Initialization (If required then only)
        if ( Instance == null )
        {
            // Thread Safe. Might be costly operation in some case
            synchronized ( OKW_Properties.class )
            {
                if ( Instance == null )
                {
                    Instance = new OKW_Properties();
                }
            }
        }
        return Instance;
    }
    
    
    private OKW_Properties()
    {
        super();
        init();
    }
    
    public void clear()
    {
        super.clear();
        this.CoreProperties.clear();
        this.ResoursesProperties.clear();
        this.FileProperties.clear();
    }
 
    public void init()
    {
        String Sep = System.getProperty( "file.separator" );
        
        // Zurücksetzen...
        this.clear();
        
        Log.ResOpenList( "Find Properties..." );
        
        // =========================================
        // !. JAR - */okw/default/*/*.properties Dateien einlesen
        // =========================================
        //
        // -----------------------------------------        
        // okw-Dafault-Properties
        //
        Log.ResOpenList( "Find OKW Core Properties..." );
        
        String PropPattern = ".*okw.default.properties.*\\.properties";
        String PropPath = "okw" + Sep + "default" + Sep + "properties" + Sep;
        String PropPathWin = "okw/default/properties/";
        
        ArrayList<String> someProperties = getPropertyFiles( PropPattern, PropPath, PropPathWin);
        this.CoreProperties.addAll( someProperties );
        
        Log.ResCloseList();
 
        // =========================================
        // project specific properties 
        // =========================================
        // 
        Log.ResOpenList( "Find Project Properties..." );
        
        PropPattern = ".*okw.properties.*\\.properties";
        PropPath = "okw" + Sep + "properties" + Sep;
        PropPathWin = "okw/properties/";
        
        ArrayList<String> some3Properties = getPropertyFiles( PropPattern, PropPath, PropPathWin);
        this.ResoursesProperties.addAll( some3Properties );
        
        Log.ResCloseList();
 
        Log.ResCloseList();
        
        // =========================================
        // Read system properties and environment Vars...
        // and Update Properties-list
        // =========================================
        this.updateProperties();
 
        //PrintPropertiesSources();
    }
    
    protected ArrayList<String> getPropertyFiles( String Patternstring, String PropPath, String PropPathWin )
    {
        String loadResoure = "";
        ArrayList<String> myReturn = new ArrayList<String>();
        
        Pattern pattern = Pattern.compile( Patternstring );
        ArrayList<String> myList = (ArrayList<String>) ResourceList.getResources(pattern);
        
        
        for ( String element : myList)
        {
            Log.ResOpenList( element );
            
            if ( StringUtils.startsWith( element, PropPath) )
            {
                loadResoure = element;
            }
            else if ( StringUtils.startsWith( element, PropPathWin) )
            {
                loadResoure = element;
            }
            else
            {
                loadResoure =  PropPath + StringUtils.splitByWholeSeparator( element, PropPath )[1];
            }
            
            Log.LogPrint( "--> " + loadResoure );
            myReturn.add( loadResoure );
 
            Log.ResCloseList();
        }
        
        return myReturn;
    }
    
       
    public void updateProperties()
    {
        // 1. Löschen des HProperty Hashs...
        super.clear();
    
        // 2. Laden der Core_Properties
        
        Log.ResOpenList( "Update Properties..." );
        Log.ResOpenList( "Load OKW Core Properties..." );
        
        Collections.sort( this.CoreProperties, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareToIgnoreCase(s2);
            } } );
        
        for( String s : this.CoreProperties )
        {
              loadFromResource(s);
        }        
        Log.ResCloseList();
        
        
        // Laden/Überladen projektspezifiescher Properties aus resourcen
        Log.ResOpenList( "Load Project Properties..." );
        
        Collections.sort( this.ResoursesProperties, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareToIgnoreCase(s2);
            } } );
        
        for( String s : this.ResoursesProperties )
        {
              loadFromResource(s);
        }
        Log.ResCloseList();
    
 
        Log.ResOpenList( "Load File Properties..." );
        for( String s : this.FileProperties )
        {
              this.loadFromFile(s);
        }
        Log.ResCloseList();
        
        
        // =========================================
        // run specific properties
        // =========================================
        Log.ResOpenList( "Load System Enviroment Vars..." );       
        loadSystemEnviromentVars();
        Log.ResCloseList();
        
        Log.ResOpenList( "Load System Propertie..." );
        loadSystemProperties();
        Log.ResCloseList();
        
        Log.ResCloseList(); // "Update Properties..." 
    }
 
 
    public Boolean addResource(String fpsResourceName)
    {
        Boolean lvbReturn = true;
 
        lvbReturn = this.ResoursesProperties.add(fpsResourceName);
 
        updateProperties();
 
        return lvbReturn;
    }
    
    
    public void addPropertiesFile(String fpsFileName)
    {
        this.FileProperties.add(fpsFileName);
        updateProperties();
        return;
    }
    
    protected ArrayList<String> getPropertiesFilesFromResources(String folder) {
 
        Log.LogFunctionStartDebug("OKW_Properties.getPropertiesFilesFromResources", "folder", folder);
 
        Log.ResOpenList( "Scan folder: " + folder );
 
        ArrayList<String> Return = new ArrayList<String>();
 
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        URL url = loader.getResource(folder);
        String path = "";
 
        try {
            path = URLDecoder.decode(url.getPath(), Charset.defaultCharset().name() );
 
            String urlResourceFolder = path.replaceAll(folder, "");
 
            File[] FoldersAndFiles = new File(path).listFiles();
 
            for (File FolderOrFile : FoldersAndFiles) {
                // Wenn es sich um ein Verzeichniss handelt
                if (FolderOrFile.isDirectory())
                {
                    // System.out.println( "Folder:" + FolderOrFile.getPath() );
                    String Folder = FolderOrFile.getPath().replaceAll(urlResourceFolder, "");
                    Return.addAll(getPropertiesFilesFromResources(Folder));
                }
                else if (FolderOrFile.isFile())
                {
                    // Nur Aufnahmen wenn mit .properies endet
                    if (FolderOrFile.getName().endsWith((".properties")))
                    {
                        // Log.LogPrint( "Property-File: " + FolderOrFile.getPath());
                        
                        Log.LogPrint( folder + "/" + FolderOrFile.getName().replaceAll(urlResourceFolder, "") );
                        Return.add( folder + "/" + FolderOrFile.getName().replaceAll(urlResourceFolder, ""));
                    }
                }
            }
 
        }
        catch (UnsupportedEncodingException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally
        {
            Log.ResCloseList();
            Log.LogFunctionEndDebug();
        }
        return Return;
    }
    
    
    
    private Boolean loadFromResource(String fpsResource )
    {
        InputStream overwrites = Thread.currentThread().getContextClassLoader().getResourceAsStream( fpsResource );
                
        Boolean lvbReturn = false;
        
        String myLogPrint = "Load Resource: " + fpsResource;
 
        try
        {
            if (overwrites != null) 
            {
                this.load(overwrites);
                overwrites.close();
                lvbReturn = true;
                myLogPrint = myLogPrint + " - OK";
            }
            else
            {
                myLogPrint = myLogPrint + " - not found!";
            }
        }
        catch (IOException e)
        {
            lvbReturn = false;
            myLogPrint = myLogPrint + " - failed!";
        }
 
        Log.LogPrint( myLogPrint );
        return lvbReturn;
    }
    
    
    private Boolean loadFromFile(String fpsPropertiesFile)
    {
        FileInputStream propFile;
        Boolean lvbReturn = false;
 
        try
        {
            File myFile = new File(fpsPropertiesFile);
            
            if ( myFile.exists() )
            {
                propFile = new FileInputStream( new File(fpsPropertiesFile) );
                this.load(propFile);
                propFile.close();
                lvbReturn = true;
            }
            else
            {
                lvbReturn = false;
                throw new OKWFileDoesNotExistsException( "File: " + fpsPropertiesFile + " does not exists." );
            }
        }
        catch ( Exception e)
        {
            throw new OKWFileDoesNotExistsException( "File: " + fpsPropertiesFile + " does not exists.", e );
        }
        return lvbReturn;
    }
 
    // =================================================================================
    // Listing the currently defined environment variables and system properties in Java
    // =================================================================================
    // https://www.javamex.com/tutorials/misc-system/environment-variables-listing.shtml
    // https://www.baeldung.com/java-system-get-property-vs-system-getenv
    private void loadSystemEnviromentVars()
    {
          Map<String, String> env = System.getenv();
    
          Log.ResOpenList( "System Enviroment Vars..." );
          
          for (String key : env.keySet())
          {
              String value = env.get(key);
              if (this.containsKey(key))
              {
                 Log.LogPrint( "Override: " + key + ": '" + this.get(key) + "'");
                 Log.LogPrint( "    with: " + key + ": '" + value + "'");
              }
              else
              {
                 Log.LogPrint( "   Write: " + key + ": '" + value + "'");
              }
              this.setProperty(key, value);
          }
          
          Log.ResCloseList();
    }
 
 
    // https://www.baeldung.com/java-system-get-property-vs-system-getenv
    private void loadSystemProperties()
    {
          Properties mySystemProperties = System.getProperties();
 
          Set<String> keys = mySystemProperties.stringPropertyNames();
 
          Log.ResOpenList( "System Properties..." );
 
          for ( String key : keys )
          {
              String value = (String) mySystemProperties.get(key);
              
              if ( this.containsKey( key ) )
              {
                 Log.LogPrint( "Override: " + key + ": '" + this.get(key) + "'" );
                 Log.LogPrint( "    with: " + key + ": '" + value + "'" );
              }
              else
              {
                 Log.LogPrint( "   Write: " + key + ": '" + value + "'" );
              }
              
              this.setProperty(key, value);
          }
          
          Log.ResCloseList();
    }
 
 
    public void PrintProperties()
    {
 
        Log.ResOpenList( "List of Properties..." );
 
        SortedMap<Object, Object> sortedSystemProperties = new TreeMap<Object, Object>(this);
        Set<Object> keySet = sortedSystemProperties.keySet();
        Iterator<Object> iterator = keySet.iterator();
 
        while (iterator.hasNext()) {
            String propertyName = (String) iterator.next();
            String propertyValue = this.getProperty(propertyName);
            Log.LogPrint( propertyName + ": " + propertyValue );
        }
        
        Log.ResCloseList();
    }
 
 
    public void PrintPropertiesSources()
    {
 
        Iterator<String> iterator = null;
        Log.ResOpenList( "Properties Sources..." );
        
        // =============================================
        // Core sources
        // =============================================
        Log.ResOpenList( "Core sources..." );
        iterator = CoreProperties.iterator();
 
        while ( iterator.hasNext())
        {
            String  mySource = iterator.next();
            Log.LogPrint( mySource );
        }
        
        Log.ResCloseList();
        
        // =============================================
        // Project specific sources
        // =============================================
 
        Log.ResOpenList( "Project specific sources..." );
        iterator = ResoursesProperties.iterator();
 
        while ( iterator.hasNext())
        {
            String  mySource = iterator.next();
            Log.LogPrint( mySource );
        }
        Log.ResCloseList();
 
        // =============================================
        // File sources
        // =============================================
 
        Log.ResOpenList( "File sources..." );
        iterator = FileProperties.iterator();
 
        while ( iterator.hasNext())
        {
            String  mySource = iterator.next();
            Log.LogPrint( mySource );
        }
        Log.ResCloseList();
 
        
        Log.ResCloseList();
 
    }
 
 
    public ArrayList<String> getKeysStartswith( String Startwitth ) throws IOException
    {
        ArrayList<String> Return = new ArrayList<String>();
 
        Set<String> keys = this.stringPropertyNames();
 
        for ( String key : keys )
        {
            if ( key.startsWith( Startwitth ) )
            {
                Return.add( key );
            }
        }
        return Return;
    }
    
    
    public ArrayList<String> getPropertiesForKeysStartswith( String Startwith ) throws IOException
    {
        ArrayList<String> Return = new ArrayList<String>();
 
        Set<String> keys = this.stringPropertyNames();
 
        for ( String key : keys )
        {
            if ( key.startsWith( Startwith ) )
            {
                Return.add( this.getProperty( key ) );
            }
        }
        return Return;
    }
 
    
   @Override
   public String getProperty(String fpsKey)
   {
        String lvsReturn = "";
        String lvsKey = "";
        
        lvsKey = Parser.ParseMe( fpsKey );
 
        lvsReturn = super.getProperty( lvsKey );
        if ( lvsReturn == null )
            okw.log.Logger_Sngltn.getInstance().LogWarning( "Propertykey (parsed) not found: '" + lvsKey + "'" );
        else
            lvsReturn = Parser.ParseMe( lvsReturn );
        
        return lvsReturn;
    }
    
    
    public String getProperty( String fpsKey, String fpsDefault, Object... Parameters )
    {
        String lvsReturn = "";
        String lvsTemplate = "";
 
        if (fpsDefault == null)
        {
           lvsTemplate = this.getProperty( fpsKey );
        }
        else
        {
           lvsTemplate = this.getProperty( fpsKey, fpsDefault );
        }
 
        if ( lvsTemplate == null )
            okw.log.Logger_Sngltn.getInstance().LogWarning( "Propertykey not found: '" + fpsKey + "'" );
        else
        {
            // Iterieren wir über alle Parameters...
            ST st = new ST( lvsTemplate, '%', '%' );
 
            for ( Integer i=0; i<Parameters.length; i++ )
            {
                Integer J = i+1;
                String PName = "P" + J.toString();
                Object Value = Parameters[i];
                st.add( PName, Value );
            }
 
            lvsReturn = st.render();
        }
 
        return lvsReturn;
    }
    
//
//
//    /**
//     * \~german
//     * Ermittelt den aktuellen Wert des Propertys gegeben mit dem Schlüssel fpsKey und es werdem $P1$ mit Parameter_1 und $P2$ mit Parameter_2 ersetzt.
//     * 
//     * @param fpsKey Schlüssel des Propertys.
//     * @param Parameter_1 Wert, der für $P1$ eingesetzt wird.
//     * @param Parameter_2 Wert, der für $P2$ eingesetzt wird.
//     * 
//     * @return Wert des Properties gegeben als fpsKey und $P1$, $P2$ wird mit den Werten von Parameter_1, Parameter_2 ersetzt.
//     * 
//     *  \~english
//     * Ermittelt den aktuellen Wert des Propertys gegeben mit dem Schlüssel fpsKey und es werdem $P1$ mit Parameter_1 und $P2$ mit Parameter_2 ersetzt.
//     * 
//     * @param fpsKey Key of Propertys.
//     * @param Parameter_1 Value that is used for $P1$.
//     * @param Parameter_2 Value that is used for $P2$.
//     * 
//     * @return Value of the property given as fpsKey and $P1$, $P2$ will be replaced with the values of parameter_1, parameter_2
//     * 
//     *  \~
//     *  @author Zoltan Hrabovszki
//     *  @date 2019-12-21
//     */
//    public String getProperty( String fpsKey, String fpsDefault, Object Parameter_1, Object Parameter_2 )
//    {
//        String lvsReturn = "";
//        String lvsTemplate = "";
//    
//        lvsTemplate = this.getProperty( fpsKey );
//        
//        if ( lvsTemplate == null )
//            okw.log.Logger_Sngltn.getInstance().LogWarning( "Propertykey not found: '" + lvsTemplate + "'" );
//        else
//        {
//        ST st = new ST( lvsTemplate, '%', '%' );
//        st.add( "P1", Parameter_1 );
//        st.add( "P2", Parameter_2 );
//        lvsReturn = st.render();
//        }
//        return lvsReturn;
//    }
 
   public Boolean getProperty2Boolean(String fpsKey, String fpsDefault )
   {
        Boolean lvbReturn = false;
        String lvsReturn = "";       
        
        lvsReturn = this.getProperty( fpsKey, fpsDefault );
        lvbReturn = Boolean.parseBoolean( lvsReturn );
 
        return lvbReturn;
    }
}