Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * This program is free software; you can redistribute it and/or modify it under the
   * terms of the GNU Lesser General Public License, version 2.1 as published by the Free Software
   * Foundation.
   *
   * You should have received a copy of the GNU Lesser General Public License along with this
   * program; if not, you can obtain a copy at http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
   * or from the Free Software Foundation, Inc.,
   * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * 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 Lesser General Public License for more details.
  *
  * Copyright (c) 2011 Pentaho Corporation..  All rights reserved.
  */
 package org.pentaho.metadata.util;
 
 import java.util.List;
 
This utility class imports and exports all localized strings that exist in a Pentaho Metadata domain.

Author(s):
Will Gorman (wgorman@pentaho.com)
 
 public class LocalizationUtil {
   
   private static final Log logger = LogFactory.getLog(LocalizationUtil.class);
   
   protected void exportLocalizedPropertiesRecursively(Properties propsIConcept parentString locale) {
     for (String propName : parent.getChildProperties().keySet()) {
       if (parent.getChildProperty(propNameinstanceof LocalizedString) {
         // externalize string
         String key = stringizeTokens(parent.getUniqueId()) + ".[" + escapeKey(propName) + "]";
         LocalizedString lstr = (LocalizedString)parent.getChildProperty(propName);
         String value = lstr.getLocalizedString(locale);
         if (value == nullvalue = "";
         props.setProperty(keyvalue);
       }
     }
     if (parent.getChildren() != null) {
       for (IConcept child : parent.getChildren()) {
         exportLocalizedPropertiesRecursively(propschildlocale);
       }
     } else {
       if (.isDebugEnabled()) {
         .debug("concept " + stringizeTokens(parent.getUniqueId()) + " does not have children");
       }
     }
   }
  
  
This method creates a properties bundle containing all the localized strings for a specific locale in a domain

Parameters:
domain the domain object to extract localized strings from
locale the locale to extract
Returns:
a properties object containing all the localized strings
 
   public Properties exportLocalizedProperties(Domain domainString locale) {
     Properties props = new Properties();
     exportLocalizedPropertiesRecursively(propsdomainlocale);
     return props;
   }
 
   protected int findCloseBracket(String keyint start) {
     int end = key.indexOf("]"start);
     if (end == -1) {
       return -1;
     }
     if (end != key.length() - 1) {
       if (key.charAt(end + 1) == ']') {
         return findCloseBracket(keyend+2);
       }
     }
     return end;
   }
   
   protected String escapeKey(String key) {
     if (key.indexOf("]") < 0) {
       return key;
     }
     return key.replaceAll("\\]""\\]\\]");
     
   }
   protected String unescapeKey(String key) {
     if (key.indexOf("]") < 0) {
       return key;
     }
     return key.replaceAll("\\]\\]""\\]");
  }
  
  protected String stringizeTokens(List<Stringkeys) {
    if (keys.size() == 0) return null;
    String key = "[" + escapeKey(keys.get(0)) + "]";
    for (int i = 1; i < keys.size(); i++) {
      key += ".[" + escapeKey(keys.get(i)) + "]";
    }
    return key;
  }
  
  protected List<StringsplitTokens(String key) {
    List<Stringtokens = new ArrayList<String>();
    int start = key.indexOf("[");
    while (start >= 0) {
      int end = findCloseBracket(keystart+1);
      if (end == -1) {
        // invalid token, return null
        return null;
      }
      tokens.add(unescapeKey(key.substring(start + 1, end)));
      start = key.indexOf("["end);
    }
    return tokens;
  }
  
  
This method returns a list of missing and extra keys specified in a properties bundle

Parameters:
domain the domain object to analyze
props the imported properties to analyze
locale the locale to analyze
Returns:
messages
  public List<StringanalyzeImport(Domain domainProperties propsString locale) {
    ArrayList<Stringmessages = new ArrayList<String>();
    
    // determine missing strings
    Properties origProps = exportLocalizedProperties(domainlocale);
    Properties cloneOrig = (Properties)origProps.clone();
    for (Object key : origProps.keySet()) {
      if (props.containsKey(key)) {
        cloneOrig.remove(key);
      }
    }
    
    // anything left in cloneOrig was missing
    for (Object key : cloneOrig.keySet()) {
      messages.add(Messages.getString("LocalizationUtil.MISSING_KEY_MESSAGE"key));
    }
    
    // determine extra strings
    Properties cloneProps = (Properties)props.clone();
    
    for (Object key : props.keySet()) {
      if (origProps.containsKey(key)) {
        cloneProps.remove(key);
      }
    }
    
    // anything left in cloneProps was extra
    for (Object key : cloneProps.keySet()) {
      messages.add(Messages.getString("LocalizationUtil.EXTRA_KEY_MESSAGE"key));
    }    
    
    return messages;
  }
  
  
This method imports a set of localized properties to a specific locale within the metadata model TODO: Do more warn logging on missing keys

Parameters:
domain Domain object to populate
props Properties object to extract key value pairs from
locale the locale in which to populate
  public void importLocalizedProperties(Domain domainProperties propsString locale) {
    // Add new locale if it does not already exist in the domain
    List<LocaleTypelocaleTypes = domain.getLocales();
    boolean addLocale = true;
    
    if(localeTypes != null) {
      for(LocaleType localeType : localeTypes) {
        if(localeType.getCode().equals(locale)) {
          addLocale = false;
          break;
        }
      }
    }
    
    if(addLocale) {
      LocaleType localeType = new LocaleType();
      localeType.setCode(locale);
      
      domain.addLocale(localeType);
    }
    
    for (Object key : props.keySet()) {
      String k = (String)key;
      if (.isDebugEnabled()) {
        .debug("importing key " + k + "=" + props.getProperty(k));
      }
      List<Stringtokens = splitTokens(k);
      if (tokens != null && tokens.size() >= 1) {
        String property = tokens.remove(tokens.size() - 1);
        IConcept concept = domain.getChildByUniqueId(tokens);
        if (concept != null) {
          LocalizedString localizedString = (LocalizedString)concept.getProperty(property);
          if (localizedString != null) {
            localizedString.setString(localeprops.getProperty(k));
          }
        }
      }
    }
  }
New to GrepCode? Check out our FAQ X