// do this only for reference language!
public List<I18nItem> getDouplicateValues() {
Locale refLocale = I18nModule.getDefaultLocale();
List<I18nItem> doupList = new ArrayList<I18nItem>();
List<String> allBundles = I18nModule.getBundleNamesContainingI18nFiles();
Map<String, String> tempKeyMap = new HashMap<String, String>();
for (String bundleName : allBundles) {
Properties properties =
i18nMgr.getPropertiesWithoutResolvingRecursively(refLocale, bundleName);
for (Iterator<Entry<Object, Object>> keyIter = properties.entrySet().iterator();
keyIter.hasNext(); ) {
Entry<Object, Object> keyEntry = keyIter.next();
String keyName = (String) keyEntry.getKey();
String keyValue = (String) keyEntry.getValue();
if (tempKeyMap.containsKey(keyName)) {
List<I18nItem> tmpItem =
i18nMgr.findI18nItemsByValueSearch(keyValue, refLocale, refLocale, bundleName, false);
doupList.addAll(tmpItem);
} else {
tempKeyMap.put(keyValue, keyName);
}
}
}
log.info("found " + doupList.size() + " douplicated values in keys");
return doupList;
}
/** @param reallyRemoveIt true: really remove it; false: dry run, only produce logging */
public void removeXKeysTask(boolean reallyRemoveIt) {
List<String> allBundles = I18nModule.getBundleNamesContainingI18nFiles();
Set<String> allLangs = getAllLanguages();
int counter = 0;
for (String langKey : allLangs) {
Locale locale = i18nMgr.getLocaleOrNull(langKey);
for (String bundleName : allBundles) {
Properties properties =
i18nMgr.getPropertiesWithoutResolvingRecursively(locale, bundleName);
Set<Object> keys = properties.keySet();
for (Object keyObj : keys) {
String key = (String) keyObj;
if (key.endsWith("X")) {
String value = properties.getProperty(key);
if (StringHelper.containsNonWhitespace(value)) {
log.warn(
"NONEMPTY XKEY detected in lang::"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key
+ " value::"
+ value);
if (reallyRemoveIt) {
addKey(locale, bundleName, key.substring(0, key.length() - 1), value);
}
}
log.info(
"XKEY detected in lang::"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key);
logText.append(
i18nMgr.getPropertiesFile(
locale, bundleName, I18nModule.getPropertyFilesBaseDir(locale, bundleName))
+ " XKEY detected in lang::"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key
+ " value::"
+ value
+ "\n");
if (reallyRemoveIt) {
deleteKey(locale, bundleName, key);
}
counter++;
}
}
}
}
if (reallyRemoveIt) {
log.info(counter + " X-Keys got removed!");
}
}
/** @param reallyRemoveIt true: really remove it; false: dry run, only produce logging */
public void removeTodoKeysTask(boolean reallyRemoveIt) {
List<String> allBundles = I18nModule.getBundleNamesContainingI18nFiles();
Set<String> allLangs = getAllLanguages();
int counter = 0;
String[] comparisonStrings = {"TODO"};
for (String langKey : allLangs) {
Locale locale = i18nMgr.getLocaleOrNull(langKey);
for (String bundleName : allBundles) {
Properties properties =
i18nMgr.getPropertiesWithoutResolvingRecursively(locale, bundleName);
Set<Object> keys = properties.keySet();
for (Object keyObj : keys) {
String key = (String) keyObj;
String value = properties.getProperty(key);
for (int i = 0; i < comparisonStrings.length; i++) {
int pos = value.toLowerCase().indexOf(comparisonStrings[i].toLowerCase());
if (pos != -1 && pos < 2 && !value.toLowerCase().equals("todos")) {
log.info(
"TODO-Key detected in lang::"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key
+ " value::"
+ value);
if (value.length() > comparisonStrings[i].length() + 1) {
log.warn(
"this is a TODO-Key WITH TEXT::"
+ value.substring(comparisonStrings[i].length())
+ "::");
} else {
logText.append(
i18nMgr.getPropertiesFile(
locale,
bundleName,
I18nModule.getPropertyFilesBaseDir(locale, bundleName))
+ " TODO-Key detected in lang::"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key
+ " value::"
+ value
+ "\n");
if (reallyRemoveIt) {
deleteKey(locale, bundleName, key);
}
}
counter++;
}
}
} // each key
} // each bundle
}
log.info(counter + " TODO-Keys got removed!");
}
private File getBundlePath(String bundleName) {
Locale locale = I18nModule.getAllLocales().get("de");
File baseDir = I18nModule.getPropertyFilesBaseDir(locale, bundleName);
if (baseDir != null) {
File deFile = I18nManager.getInstance().getPropertiesFile(locale, bundleName, baseDir);
return deFile.getParentFile();
}
return null;
// I18nManager.getInstance().
// bundleName = bundleName.replace('.', '/');
// String relPath = "/" + bundleName + "/" + I18nManager.I18N_DIRNAME + "/";
// String bundlePath = getTransToolCoreLanguagesSrcDir().getAbsolutPath() + relPath;
// return new File(bundlePath);
}
/** @param reallyRemoveIt true: really remove it; false: dry run, only produce logging */
public void removeEmptyKeysTask(boolean reallyRemoveIt) {
List<String> allBundles = I18nModule.getBundleNamesContainingI18nFiles();
int counter = 0;
Set<String> allLangs = getAllLanguages();
for (String langKey : allLangs) {
Locale locale = i18nMgr.getLocaleOrNull(langKey);
for (String bundleName : allBundles) {
Properties properties =
i18nMgr.getPropertiesWithoutResolvingRecursively(locale, bundleName);
Set<Object> keys = properties.keySet();
for (Object keyObj : keys) {
String key = (String) keyObj;
String value = properties.getProperty(key);
if (!StringHelper.containsNonWhitespace(value)) {
log.info(
"empty Key detected in lang::"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key
+ " value::"
+ value);
logText.append(
i18nMgr.getPropertiesFile(
locale, bundleName, I18nModule.getPropertyFilesBaseDir(locale, bundleName))
+ " empty Key detected in lang"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key
+ " value::"
+ value
+ "\n");
if (reallyRemoveIt) {
deleteKey(locale, bundleName, key);
}
}
counter++;
} // each key
} // each bundle
}
log.info(counter + " empty Keys got removed!");
}
public void movePackageByMovingSingleKeysTask(String originBundleName, String targetBundleName) {
Properties properties =
i18nMgr.getPropertiesWithoutResolvingRecursively(
I18nModule.getFallbackLocale(), originBundleName);
Set<Object> keys = properties.keySet();
for (Object keyObj : keys) {
String key = (String) keyObj;
moveKeyToOtherBundle(originBundleName, targetBundleName, key);
}
}
public void sortKeysTask(boolean reallySortIt) {
List<String> allBundles = I18nModule.getBundleNamesContainingI18nFiles();
Set<String> allLangs = getAllLanguages();
int counter = 0;
for (String langKey : allLangs) {
Locale locale = i18nMgr.getLocaleOrNull(langKey);
for (String bundleName : allBundles) {
Properties properties =
i18nMgr.getPropertiesWithoutResolvingRecursively(locale, bundleName);
if (reallySortIt) {
// since opened as SortedProperties, save will sort it. Nothing changed, just resorted
if (properties.size() != 0) {
i18nMgr.saveOrUpdateProperties(properties, locale, bundleName);
}
} else {
log.info("Sorting " + langKey + ":" + bundleName);
}
counter++;
}
}
log.info("Sorted " + counter + " properties files");
}
public void renameLanguageTask(Locale sourceLocale, Locale targetLocale) {
// check if targetLocale exists already
Set<String> allLangKeys = I18nModule.getAvailableLanguageKeys();
if (allLangKeys.contains(targetLocale.getLanguage())) {
log.error("Target Language " + targetLocale.getLanguage() + " already exists! ");
} else {
// get All items from sourceLocale, copy to targetLocale and delete sourceLocale
List<I18nItem> items = i18nMgr.findExistingI18nItems(sourceLocale, null, true);
for (I18nItem item : items) {
String bundleName = item.getBundleName();
String itemKey = item.getKey();
I18nItem targetTempItem =
new I18nItem(
bundleName, itemKey, targetLocale, item.getBundlePriority(), item.getKeyPriority());
Properties prop =
i18nMgr.getPropertiesWithoutResolvingRecursively(sourceLocale, bundleName);
String value = prop.getProperty(itemKey);
i18nMgr.saveOrUpdateI18nItem(targetTempItem, value);
deleteKey(sourceLocale, bundleName, itemKey);
}
}
}
/**
* Main method called by DispatcherAction. This processess all requests for authenticated users.
*
* @param request
* @param response
* @param uriPrefix
*/
@Override
public void execute(
final HttpServletRequest request,
final HttpServletResponse response,
final String uriPrefix) {
long startExecute = 0;
if (log.isDebugEnabled()) {
startExecute = System.currentTimeMillis();
}
final UserSession usess = UserSession.getUserSession(request);
UserRequest ureq = null;
try {
// upon creation URL is checked for
ureq = new UserRequest(uriPrefix, request, response);
} catch (final NumberFormatException nfe) {
// MODE could not be decoded
// typically if robots with wrong urls hit the system
// or user have bookmarks
// or authors copy-pasted links to the content.
// showing redscreens for non valid URL is wrong instead
// a 404 message must be shown -> e.g. robots correct their links.
if (log.isDebugEnabled()) {
log.debug("Bad Request " + request.getPathInfo());
}
DispatcherAction.sendBadRequest(request.getPathInfo(), response);
return;
}
// GUIInterna.setLoadPerformanceMode(ureq);
// GUIInterna.setUserSession (usess);
final boolean auth = usess.isAuthenticated();
if (!auth) {
if (!ureq.isValidDispatchURI()) {
// might be a direct jump request -> remember it if not logged in yet
final String reqUri = request.getRequestURI();
final String query = request.getQueryString();
final String allGet = reqUri + QUESTIONMARK + query;
usess.putEntryInNonClearedStore(AUTHDISPATCHER_ENTRYURL, allGet);
}
final String guestAccess = ureq.getParameter(GUEST);
if (guestAccess == null || !LoginModule.isGuestLoginLinksEnabled()) {
DispatcherAction.redirectToDefaultDispatcher(response);
return;
} else if (guestAccess.equals(TRUE)) {
// try to log in as anonymous
// use the language from the lang paramter if available, otherwhise use the system default
// locale
final String guestLang = ureq.getParameter("lang");
Locale guestLoc;
if (guestLang == null) {
guestLoc = I18nModule.getDefaultLocale();
} else {
guestLoc = I18nManager.getInstance().getLocaleOrDefault(guestLang);
}
final int loginStatus = AuthHelper.doAnonymousLogin(ureq, guestLoc);
if (loginStatus != AuthHelper.LOGIN_OK) {
if (loginStatus == AuthHelper.LOGIN_NOTAVAILABLE) {
DispatcherAction.redirectToServiceNotAvailable(response);
}
DispatcherAction.redirectToDefaultDispatcher(response); // error, redirect to login screen
return;
}
// else now logged in as anonymous user, continue
}
}
// authenticated!
try {
// kill session if not secured via SSL
if (forceSecureAccessOnly && !request.isSecure()) {
final SessionInfo sessionInfo = usess.getSessionInfo();
if (sessionInfo != null) {
final HttpSession session = sessionInfo.getSession();
if (session != null) {
try {
session.invalidate();
} catch (final IllegalStateException ise) {
// thrown when session already invalidated. fine. ignore.
}
}
}
DispatcherAction.redirectToDefaultDispatcher(response);
return;
}
final SessionInfo sessionInfo = usess.getSessionInfo();
if (sessionInfo == null) {
DispatcherAction.redirectToDefaultDispatcher(response);
return;
}
if (userBasedLogLevelManager != null) {
userBasedLogLevelManager.activateUsernameBasedLogLevel(sessionInfo.getLogin());
}
sessionInfo.setLastClickTime();
final String origUrl = (String) usess.removeEntryFromNonClearedStore(AUTHDISPATCHER_ENTRYURL);
if (origUrl != null) {
// we had a direct jump request
// to avoid a endless redirect, remove the guest parameter if any
// this can happen if a guest has cookies disabled
final String url = new URIHelper(origUrl).removeParameter(GUEST).toString();
DispatcherAction.redirectTo(response, url);
return;
}
final String businessPath =
(String) usess.removeEntryFromNonClearedStore(AUTHDISPATCHER_BUSINESSPATH);
if (businessPath != null) {
final BusinessControl bc =
BusinessControlFactory.getInstance().createFromString(businessPath);
final ChiefController cc =
(ChiefController) Windows.getWindows(usess).getAttribute("AUTHCHIEFCONTROLLER");
if (cc == null) {
log.error("I-130611-0017 [url=" + request.getRequestURI());
}
final WindowControl wControl = cc.getWindowControl();
final WindowControl bwControl =
BusinessControlFactory.getInstance().createBusinessWindowControl(bc, wControl);
NewControllerFactory.getInstance().launch(ureq, bwControl);
// render the window
final Window w = cc.getWindow();
w.dispatchRequest(ureq, true); // renderOnly
return;
}
if (ureq.isValidDispatchURI()) { // valid uri for dispatching (has timestamp, componentid and
// windowid)
final Windows ws = Windows.getWindows(ureq);
final Window window = ws.getWindow(ureq);
if (window == null) {
// If no window, this is probably a stale link. send not
// found
// note: do not redirect to login since this wastes a new
// window each time since we are in an authenticated session
// -> a content packaging with wrong links e.g. /css/my.css
// wastes all the windows
DispatcherAction.sendNotFound(request.getRequestURI(), response);
return;
}
long startDispatchRequest = 0;
if (log.isDebugEnabled()) {
startDispatchRequest = System.currentTimeMillis();
}
window.dispatchRequest(ureq);
if (log.isDebugEnabled()) {
final long durationDispatchRequest = System.currentTimeMillis() - startDispatchRequest;
log.debug("Perf-Test: window=" + window);
log.debug("Perf-Test: durationDispatchRequest=" + durationDispatchRequest);
}
}
} catch (final Throwable th) {
// Do not log as Warn or Error here, log as ERROR in MsgFactory => ExceptionWindowController
// throws an OLATRuntimeException
log.debug("handleError in AuthenticatedDispatcher throwable=" + th);
DispatcherAction.handleError();
final ChiefController msgcc = MsgFactory.createMessageChiefController(ureq, th);
// the controller's window must be failsafe also
msgcc.getWindow().dispatchRequest(ureq, true);
// do not dispatch (render only), since this is a new Window created as
// a result of another window's click.
} finally {
if (userBasedLogLevelManager != null) {
userBasedLogLevelManager.deactivateUsernameBasedLogLevel();
}
if (log.isDebugEnabled()) {
final long durationExecute = System.currentTimeMillis() - startExecute;
log.debug("Perf-Test: durationExecute=" + durationExecute);
}
// XX:GUIInterna.setLoadPerformanceMode(null);
}
}
/** @param reallyRemoveIt true: really remove it; false: dry run, only produce logging */
public void removeReferenceLanguageCopiesTask(boolean reallyRemoveIt) {
List<String> allBundles = I18nModule.getBundleNamesContainingI18nFiles();
// don't remove EN and DE here, this is a shared Map!!
int counter = 0;
int aliasCounter = 0;
// prepare exclusion list
String exKeys =
FileUtils.load(
new File(
I18nModule.getTransToolApplicationLanguagesSrcDir()
+ "/org/olat/lms/commons/i18n/devtools/exclusionKeys.txt"),
"UTF-8");
String[] exArray = exKeys.split("\n");
List<String> exList = new ArrayList<String>(Arrays.asList(exArray));
Set<String> allLangs = getAllLanguages();
for (String langKey : allLangs) {
Locale locale = i18nMgr.getLocaleOrNull(langKey);
if (locale.toString().equals("de") || locale.toString().equals("en")) {
// don't compare with DE and EN itself
continue;
}
for (String bundleName : allBundles) {
Properties properties =
i18nMgr.getPropertiesWithoutResolvingRecursively(locale, bundleName);
Properties refPropDe =
i18nMgr.getPropertiesWithoutResolvingRecursively(new Locale("de"), bundleName);
Properties refPropEn =
i18nMgr.getPropertiesWithoutResolvingRecursively(new Locale("en"), bundleName);
Set<Object> keys = properties.keySet();
for (Object keyObj : keys) {
String key = (String) keyObj;
// dont handle if in exclusion list
if (!exList.contains(key)) {
String value = properties.getProperty(key);
// get ref-lang. value and compare:
boolean foundInReferenceDe = false;
boolean foundInReferenceEn = false;
if (value.equals(refPropDe.getProperty(key))) {
log.info(
"Value of Key found in reference Language DE. lang::"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key
+ " value::"
+ value);
foundInReferenceDe = true;
}
if (value.equals(refPropEn.getProperty(key))) {
log.info(
"Value of Key found in reference Language EN. lang::"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key
+ " value::"
+ value);
foundInReferenceEn = true;
}
// probably an alias if found in both ref. lang.
boolean readyToDelete = (foundInReferenceDe || foundInReferenceEn);
if (foundInReferenceDe && foundInReferenceEn) {
log.info(
"Matching value in both reference languages. lang::"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key
+ " value::"
+ value);
readyToDelete = false;
aliasCounter++;
}
if (readyToDelete && reallyRemoveIt) {
deleteKey(locale, bundleName, key);
}
if (readyToDelete) {
counter++;
logText.append(
i18nMgr.getPropertiesFile(
locale,
bundleName,
I18nModule.getPropertyFilesBaseDir(locale, bundleName))
+ " value of key found in reference -> remove lang::"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key
+ " value::"
+ value
+ "\n");
}
}
}
}
}
log.info(counter + " Keys found/deleted with values copied from only one reference languages!");
log.info(aliasCounter + " Keys which seems to be alias found and NOT deleted!");
}
protected Set<String> getAllLanguages() {
return I18nModule.getTranslatableLanguageKeys();
}
/**
* once again check for keys in branch (lost keys) and move them to Head reallyCopy: set to true
* to create Props/keys in Head, false: only log them
*/
public void getLostTranslationsFromBranch(
boolean reallyCopy,
String[] referenceLanguages,
String pathToOlatBranch,
String pathToCoreBranch) {
List<String> allBundles = new ArrayList<String>(I18nModule.getBundleNamesContainingI18nFiles());
Set<String> allLangs = getAllLanguages();
// loop over all langs
int totalCounter = 0;
for (String langKey : allLangs) {
int langCounter = 0;
// ignore ref langs
boolean isRefLang = false;
for (String refLangKey : referenceLanguages) {
if (refLangKey.equals(langKey)) {
isRefLang = true;
break;
}
}
if (isRefLang) continue;
// load current language
Locale locale = i18nMgr.getLocaleOrNull(langKey);
for (String bundleName : allBundles) {
int bundleCounter = 0;
// get valid keys from ref langs and this bundle
Set<String> allValidKeys = new HashSet<String>();
for (String refLangKey : referenceLanguages) {
Properties properties =
i18nMgr.getPropertiesWithoutResolvingRecursively(
i18nMgr.getLocaleOrNull(refLangKey), bundleName);
if (properties == null) {
throw new OLATRuntimeException("Invalid reference language::" + refLangKey, null);
} else {
for (Object keyObj : properties.keySet()) {
String key = (String) keyObj;
allValidKeys.add(key);
}
}
} // for
// check if bundle + this locale exists in branch
String bundlePath = bundleName.replace(".", "/");
String langPropFileName =
I18nModule.LOCAL_STRINGS_FILE_PREFIX + langKey + I18nModule.LOCAL_STRINGS_FILE_POSTFIX;
File bundleInOlat =
new File(
pathToOlatBranch
+ bundlePath
+ "/"
+ I18nManager.I18N_DIRNAME
+ "/"
+ langPropFileName);
File bundleInCore =
new File(
pathToCoreBranch
+ bundlePath
+ "/"
+ I18nManager.I18N_DIRNAME
+ "/"
+ langPropFileName);
File bundleToUse;
if (bundleInOlat.exists()) {
bundleToUse = bundleInOlat;
} else if (bundleInCore.exists()) {
bundleToUse = bundleInCore;
} else { // no bundle found in branch, its not even worth to look after keys
log.debug(
"getLostTrans: no OLD prop file found in BRANCH for locale: "
+ locale
+ " and bundle: "
+ bundleName
+ " => continue with next bundle");
continue;
}
// look after all valid keys in given lang in Head
Properties targetProperties =
i18nMgr.getPropertiesWithoutResolvingRecursively(locale, bundleName);
Set<Object> targetLangBundleKeys = targetProperties.keySet();
Properties oldProps = new Properties();
FileInputStream is;
try {
is = new FileInputStream(bundleToUse);
oldProps.load(is);
is.close();
} catch (Exception e) {
e.printStackTrace();
}
for (Object keyObj : allValidKeys) {
String key = (String) keyObj;
if (targetLangBundleKeys.contains(key)) {
// everything ok
} else {
// only work on keys found in reference lang (de/en) but not in this bundle
// try to load key from branch
if (oldProps.containsKey(key)) {
String oldValue = oldProps.getProperty(key);
if (StringHelper.containsNonWhitespace(oldValue)
&& !oldValue.trim().startsWith("TODO")) {
langCounter++;
bundleCounter++;
totalCounter++;
if (reallyCopy) {
addKey(locale, bundleName, key, oldValue);
} else {
log.debug(
"getLostTrans: add a key from BRANCH to locale: "
+ locale
+ " and bundle: "
+ bundleName
+ " key: "
+ key);
}
} else {
log.debug(
"getLostTrans: ignoring invalid value::'"
+ oldValue
+ "' from BRANCH to locale: "
+ locale
+ " and bundle: "
+ bundleName
+ " key: "
+ key);
}
}
}
} // for: keys
if (bundleCounter > 0)
log.info(
"Changed "
+ bundleCounter
+ " keys for locale: "
+ locale
+ " and bundle: "
+ bundleName);
} // for: bundles
if (langCounter > 0) log.info("Changed " + langCounter + " keys for locale: " + locale);
} // for: langs
if (totalCounter > 0) log.info("Changed " + totalCounter + " keys in total");
}
/**
* Check for keys that exist in target languages but not in EN or DE. Delete such keys in the
* target languages
*
* @param reallyRemoveIt true: really delete; false: verbose dry run
* @param referenceLanguages array that contains the language keys that serves as a reference
* (e.g. en and de)
* @param languages the languages that should be cleaned up
*/
public void removeDeletedKeys(
boolean reallyRemoveIt, String[] referenceLanguages, Set<String> languages) {
// first get all available keys from de and en language
Set<String> validCombinedKeys = new HashSet<String>();
// copy list to prevent concurrent modification exception
List<String> allBundles = new ArrayList<String>(I18nModule.getBundleNamesContainingI18nFiles());
for (String bundleName : allBundles) {
for (String refLangKey : referenceLanguages) {
Properties properties =
i18nMgr.getPropertiesWithoutResolvingRecursively(
i18nMgr.getLocaleOrNull(refLangKey), bundleName);
if (properties == null) {
throw new OLATRuntimeException("Invalid reference language::" + refLangKey, null);
} else {
for (Object keyObj : properties.keySet()) {
String key = (String) keyObj;
String combinedKey = bundleName + ":" + key;
validCombinedKeys.add(combinedKey);
}
}
}
}
log.info(
"removeDeletedKeys: found "
+ validCombinedKeys.size()
+ " valid keys in "
+ ArrayHelper.toString(referenceLanguages));
//
// For each language except DE and EN, go through all i18n files and
// remove keys not in the valid set
for (String langKey : languages) {
boolean isRefLang = false;
for (String refLangKey : referenceLanguages) {
if (refLangKey.equals(langKey)) {
isRefLang = true;
break;
}
}
if (isRefLang) continue;
// Not a reference language - delete from here
Locale locale = i18nMgr.getLocaleOrNull(langKey);
for (String bundleName : allBundles) {
Properties properties =
i18nMgr.getPropertiesWithoutResolvingRecursively(locale, bundleName);
int propCount = properties.size();
// copy keys to prevent concurrent modification
Set<String> availableKeys = new HashSet<String>();
for (Object key : properties.keySet()) {
availableKeys.add((String) key);
}
for (String key : availableKeys) {
String combinedKey = bundleName + ":" + key;
if (!validCombinedKeys.contains(combinedKey)) {
if (reallyRemoveIt) {
log.info(
"Deleting "
+ langKey
+ ":"
+ bundleName
+ ":"
+ key
+ " - does not exist in "
+ ArrayHelper.toString(referenceLanguages));
properties.remove(key);
} else {
log.info(
"Should be deleted: "
+ langKey
+ ":"
+ bundleName
+ ":"
+ key
+ " - does not exist in "
+ ArrayHelper.toString(referenceLanguages));
}
}
}
int delCount = (propCount - properties.size());
if (reallyRemoveIt && delCount > 0) {
// only save when changed
i18nMgr.saveOrUpdateProperties(properties, locale, bundleName);
log.info(
"For language::"
+ langKey
+ " the in bundle:: "
+ bundleName
+ " deleted "
+ delCount
+ " keys");
}
// delete empty bundles
if (reallyRemoveIt && properties.size() == 0) {
i18nMgr.deleteProperties(locale, bundleName);
log.info(
"Bundle:: "
+ bundleName
+ " deleted for language "
+ langKey
+ "entirely because it was empty");
}
}
}
}
protected void changeReferencesInValues(
String originBundleName, String targetBundleName, String origKey, String targetKey) {
// operation:
boolean movePackage = false;
boolean renameKey = false;
if (!originBundleName.equals(targetBundleName)) movePackage = true;
if (!origKey.equals(targetKey)) renameKey = true;
int counter = 0;
Pattern resolvingKeyPattern =
Pattern.compile("\\$\\{?(" + originBundleName + ")+:([\\w\\.\\-]*[\\w\\-])\\}?");
List<String> allBundles = I18nModule.getBundleNamesContainingI18nFiles();
Set<String> allLangs = getAllLanguages();
for (String langKey : allLangs) {
Locale locale = i18nMgr.getLocaleOrNull(langKey);
for (String bundleName : allBundles) {
Properties properties =
i18nMgr.getPropertiesWithoutResolvingRecursively(locale, bundleName);
Set<Object> keys = properties.keySet();
for (Object keyObj : keys) {
String key = (String) keyObj;
String value = properties.getProperty(key);
Matcher matcher = resolvingKeyPattern.matcher(value);
int lastPos = 0;
while (matcher.find()) {
String matchedKey = matcher.group(2);
String matchedBundle = matcher.group(1);
if (matchedKey.equals(origKey)
&& ((matchedBundle == null && bundleName.equals(originBundleName))
|| originBundleName.equals(matchedBundle))) {
StringBuffer newValue = new StringBuffer();
newValue.append(value.substring(0, matcher.start()));
newValue.append("$");
if (movePackage) {
if (!targetBundleName.equals(matchedBundle)) {
newValue.append(targetBundleName);
}
}
newValue.append(":");
if (renameKey) {
newValue.append(targetKey);
} else {
newValue.append(origKey);
}
lastPos = matcher.end();
newValue.append(value.substring(lastPos));
log.info("Key:: " + key + " should get changed to value:: " + newValue.toString());
logText.append(
i18nMgr.getPropertiesFile(
locale,
bundleName,
I18nModule.getPropertyFilesBaseDir(locale, bundleName))
+ " update reference in lang::"
+ locale.getLanguage()
+ " bundle::"
+ bundleName
+ " key::"
+ key
+ " value::"
+ value
+ " \n\t to new value:: "
+ newValue.toString()
+ "\n");
counter++;
// changeValueForSingleKey(locale, bundleName, key, newValue.toString());
}
}
} // each key
}
}
log.info(counter + " values have been updated.");
}
