Пример #1
0
  // 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;
  }
Пример #2
0
 /** @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!");
   }
 }
Пример #3
0
 /** @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!");
 }
Пример #4
0
 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);
 }
Пример #5
0
 /** @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!");
 }
Пример #6
0
 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);
   }
 }
Пример #7
0
 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");
 }
Пример #8
0
  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);
      }
    }
  }
Пример #9
0
  /**
   * 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);
    }
  }
Пример #10
0
  /** @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!");
  }
Пример #11
0
 protected Set<String> getAllLanguages() {
   return I18nModule.getTranslatableLanguageKeys();
 }
Пример #12
0
  /**
   * 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");
  }
Пример #13
0
 /**
  * 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");
       }
     }
   }
 }
Пример #14
0
  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.");
  }