001
014
015 package com.liferay.portal.util;
016
017 import com.liferay.portal.kernel.io.unsync.UnsyncStringReader;
018 import com.liferay.portal.kernel.io.unsync.UnsyncStringWriter;
019 import com.liferay.portal.kernel.json.JSONObject;
020 import com.liferay.portal.kernel.language.LanguageUtil;
021 import com.liferay.portal.kernel.log.Log;
022 import com.liferay.portal.kernel.log.LogFactoryUtil;
023 import com.liferay.portal.kernel.util.ArrayUtil;
024 import com.liferay.portal.kernel.util.LocaleUtil;
025 import com.liferay.portal.kernel.util.Localization;
026 import com.liferay.portal.kernel.util.ParamUtil;
027 import com.liferay.portal.kernel.util.PrefsParamUtil;
028 import com.liferay.portal.kernel.util.StringBundler;
029 import com.liferay.portal.kernel.util.StringPool;
030 import com.liferay.portal.kernel.util.StringUtil;
031 import com.liferay.portal.kernel.util.Tuple;
032 import com.liferay.portal.kernel.util.Validator;
033 import com.liferay.portal.language.LanguageResources;
034 import com.liferay.portal.security.pacl.PACLClassLoaderUtil;
035
036 import java.util.HashMap;
037 import java.util.Locale;
038 import java.util.Map;
039 import java.util.ResourceBundle;
040
041 import javax.portlet.PortletPreferences;
042 import javax.portlet.PortletRequest;
043
044 import javax.xml.stream.XMLInputFactory;
045 import javax.xml.stream.XMLOutputFactory;
046 import javax.xml.stream.XMLStreamConstants;
047 import javax.xml.stream.XMLStreamException;
048 import javax.xml.stream.XMLStreamReader;
049 import javax.xml.stream.XMLStreamWriter;
050
051 import org.apache.commons.collections.map.ReferenceMap;
052
053
061 public class LocalizationImpl implements Localization {
062
063 public Object deserialize(JSONObject jsonObject) {
064 Locale[] locales = LanguageUtil.getAvailableLocales();
065
066 Map<Locale, String> map = new HashMap<Locale, String>();
067
068 for (Locale locale : locales) {
069 String languageId = LocaleUtil.toLanguageId(locale);
070
071 String value = jsonObject.getString(languageId);
072
073 if (Validator.isNotNull(value)) {
074 map.put(locale, value);
075 }
076 }
077
078 return map;
079 }
080
081 public String[] getAvailableLocales(String xml) {
082 String attributeValue = _getRootAttribute(
083 xml, _AVAILABLE_LOCALES, StringPool.BLANK);
084
085 return StringUtil.split(attributeValue);
086 }
087
088 public Locale getDefaultImportLocale(
089 String className, long classPK, Locale contentDefaultLocale,
090 Locale[] contentAvailableLocales) {
091
092 Locale[] availableLocales = LanguageUtil.getAvailableLocales();
093
094 if (ArrayUtil.contains(availableLocales, contentDefaultLocale)) {
095 return contentDefaultLocale;
096 }
097
098 Locale defaultLocale = LocaleUtil.getDefault();
099
100 if (ArrayUtil.contains(contentAvailableLocales, defaultLocale)) {
101 return defaultLocale;
102 }
103
104 for (Locale contentAvailableLocale : contentAvailableLocales) {
105 if (ArrayUtil.contains(availableLocales, contentAvailableLocale)) {
106 return contentAvailableLocale;
107 }
108 }
109
110 if (_log.isWarnEnabled()) {
111 StringBundler sb = new StringBundler(9);
112
113 sb.append("Language ");
114 sb.append(LocaleUtil.toLanguageId(contentDefaultLocale));
115 sb.append(" is missing for ");
116 sb.append(className);
117 sb.append(" with primary key ");
118 sb.append(classPK);
119 sb.append(". Setting default language to ");
120 sb.append(LocaleUtil.toLanguageId(defaultLocale));
121 sb.append(".");
122
123 _log.warn(sb.toString());
124 }
125
126 return defaultLocale;
127 }
128
129 public String getDefaultLocale(String xml) {
130 String defaultLanguageId = LocaleUtil.toLanguageId(
131 LocaleUtil.getDefault());
132
133 return _getRootAttribute(xml, _DEFAULT_LOCALE, defaultLanguageId);
134 }
135
136 public String getLocalization(String xml, String requestedLanguageId) {
137 return getLocalization(xml, requestedLanguageId, true);
138 }
139
140 public String getLocalization(
141 String xml, String requestedLanguageId, boolean useDefault) {
142
143 String value = _getCachedValue(xml, requestedLanguageId, useDefault);
144
145 if (value != null) {
146 return value;
147 }
148 else {
149 value = StringPool.BLANK;
150 }
151
152 String systemDefaultLanguageId = LocaleUtil.toLanguageId(
153 LocaleUtil.getDefault());
154
155 String priorityLanguageId = null;
156
157 Locale requestedLocale = LocaleUtil.fromLanguageId(requestedLanguageId);
158
159 if (useDefault &&
160 LanguageUtil.isDuplicateLanguageCode(
161 requestedLocale.getLanguage())) {
162
163 Locale priorityLocale = LanguageUtil.getLocale(
164 requestedLocale.getLanguage());
165
166 if (!requestedLanguageId.equals(priorityLanguageId)) {
167 priorityLanguageId = LocaleUtil.toLanguageId(priorityLocale);
168 }
169 }
170
171 if (!Validator.isXml(xml)) {
172 if (useDefault ||
173 requestedLanguageId.equals(systemDefaultLanguageId)) {
174
175 value = xml;
176 }
177
178 _setCachedValue(xml, requestedLanguageId, useDefault, value);
179
180 return value;
181 }
182
183 XMLStreamReader xmlStreamReader = null;
184
185 ClassLoader portalClassLoader =
186 PACLClassLoaderUtil.getPortalClassLoader();
187
188 ClassLoader contextClassLoader =
189 PACLClassLoaderUtil.getContextClassLoader();
190
191 try {
192 if (contextClassLoader != portalClassLoader) {
193 PACLClassLoaderUtil.setContextClassLoader(portalClassLoader);
194 }
195
196 XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
197
198 xmlStreamReader = xmlInputFactory.createXMLStreamReader(
199 new UnsyncStringReader(xml));
200
201 String defaultLanguageId = StringPool.BLANK;
202
203
204
205 if (xmlStreamReader.hasNext()) {
206 xmlStreamReader.nextTag();
207
208 defaultLanguageId = xmlStreamReader.getAttributeValue(
209 null, _DEFAULT_LOCALE);
210
211 if (Validator.isNull(defaultLanguageId)) {
212 defaultLanguageId = systemDefaultLanguageId;
213 }
214 }
215
216
217
218 String defaultValue = StringPool.BLANK;
219 String priorityValue = StringPool.BLANK;
220
221 while (xmlStreamReader.hasNext()) {
222 int event = xmlStreamReader.next();
223
224 if (event == XMLStreamConstants.START_ELEMENT) {
225 String languageId = xmlStreamReader.getAttributeValue(
226 null, _LANGUAGE_ID);
227
228 if (Validator.isNull(languageId)) {
229 languageId = defaultLanguageId;
230 }
231
232 if (languageId.equals(defaultLanguageId) ||
233 languageId.equals(priorityLanguageId) ||
234 languageId.equals(requestedLanguageId)) {
235
236 String text = xmlStreamReader.getElementText();
237
238 if (languageId.equals(defaultLanguageId)) {
239 defaultValue = text;
240 }
241
242 if (languageId.equals(priorityLanguageId)) {
243 priorityValue = text;
244 }
245
246 if (languageId.equals(requestedLanguageId)) {
247 value = text;
248 }
249
250 if (Validator.isNotNull(value)) {
251 break;
252 }
253 }
254 }
255 else if (event == XMLStreamConstants.END_DOCUMENT) {
256 break;
257 }
258 }
259
260 if (useDefault && Validator.isNotNull(priorityLanguageId) &&
261 Validator.isNull(value) && Validator.isNotNull(priorityValue)) {
262
263 value = priorityValue;
264 }
265
266 if (useDefault && Validator.isNull(value)) {
267 value = defaultValue;
268 }
269 }
270 catch (Exception e) {
271 if (_log.isWarnEnabled()) {
272 _log.warn(e, e);
273 }
274 }
275 finally {
276 if (contextClassLoader != portalClassLoader) {
277 PACLClassLoaderUtil.setContextClassLoader(contextClassLoader);
278 }
279
280 if (xmlStreamReader != null) {
281 try {
282 xmlStreamReader.close();
283 }
284 catch (Exception e) {
285 }
286 }
287 }
288
289 _setCachedValue(xml, requestedLanguageId, useDefault, value);
290
291 return value;
292 }
293
294 public Map<Locale, String> getLocalizationMap(
295 PortletPreferences preferences, String parameter) {
296
297 Locale[] locales = LanguageUtil.getAvailableLocales();
298
299 Map<Locale, String> map = new HashMap<Locale, String>();
300
301 for (Locale locale : locales) {
302 String languageId = LocaleUtil.toLanguageId(locale);
303
304 String localeParameter = parameter.concat(
305 StringPool.UNDERLINE).concat(languageId);
306
307 map.put(
308 locale,
309 preferences.getValue(localeParameter, StringPool.BLANK));
310 }
311
312 return map;
313 }
314
315 public Map<Locale, String> getLocalizationMap(
316 PortletRequest portletRequest, String parameter) {
317
318 Locale[] locales = LanguageUtil.getAvailableLocales();
319
320 Map<Locale, String> map = new HashMap<Locale, String>();
321
322 for (Locale locale : locales) {
323 String languageId = LocaleUtil.toLanguageId(locale);
324
325 String localeParameter = parameter.concat(
326 StringPool.UNDERLINE).concat(languageId);
327
328 map.put(
329 locale, ParamUtil.getString(portletRequest, localeParameter));
330 }
331
332 return map;
333 }
334
335 public Map<Locale, String> getLocalizationMap(String xml) {
336 Locale[] locales = LanguageUtil.getAvailableLocales();
337
338 Map<Locale, String> map = new HashMap<Locale, String>();
339
340 for (Locale locale : locales) {
341 String languageId = LocaleUtil.toLanguageId(locale);
342
343 map.put(locale, getLocalization(xml, languageId, false));
344 }
345
346 return map;
347 }
348
349 public Map<Locale, String> getLocalizationMap(
350 String bundleName, ClassLoader classLoader, String key,
351 boolean includeBetaLocales) {
352
353 if (key == null) {
354 return null;
355 }
356
357 Map<Locale, String> map = new HashMap<Locale, String>();
358
359 Locale defaultLocale = LocaleUtil.getDefault();
360
361 String defaultValue = _getLocalization(
362 bundleName, defaultLocale, classLoader, key, key);
363
364 map.put(defaultLocale, defaultValue);
365
366 Locale[] locales = null;
367
368 if (includeBetaLocales) {
369 locales = LanguageUtil.getAvailableLocales();
370 }
371 else {
372 locales = LanguageUtil.getSupportedLocales();
373 }
374
375 for (Locale locale : locales) {
376 if (locale.equals(defaultLocale)) {
377 continue;
378 }
379
380 String value = _getLocalization(
381 bundleName, locale, classLoader, key, null);
382
383 if (Validator.isNotNull(value) && !value.equals(defaultValue)) {
384 map.put(locale, value);
385 }
386 }
387
388 return map;
389 }
390
391 public Map<Locale, String> getLocalizationMap(
392 String[] languageIds, String[] values) {
393
394 Map<Locale, String> map = new HashMap<Locale, String>();
395
396 for (int i = 0; i < values.length; i++) {
397 Locale locale = LocaleUtil.fromLanguageId(languageIds[i]);
398
399 map.put(locale, values[i]);
400 }
401
402 return map;
403 }
404
405 public String getLocalizationXmlFromPreferences(
406 PortletPreferences preferences, PortletRequest portletRequest,
407 String parameter) {
408
409 String xml = StringPool.BLANK;
410
411 Locale[] locales = LanguageUtil.getAvailableLocales();
412 Locale defaultLocale = LocaleUtil.getDefault();
413 String defaultLanguageId = LocaleUtil.toLanguageId(defaultLocale);
414
415 for (Locale locale : locales) {
416 String languageId = LocaleUtil.toLanguageId(locale);
417
418 String localParameter =
419 parameter + StringPool.UNDERLINE + languageId;
420
421 String value = PrefsParamUtil.getString(
422 preferences, portletRequest, localParameter);
423
424 if (Validator.isNotNull(value)) {
425 xml = updateLocalization(xml, parameter, value, languageId);
426 }
427 }
428
429 if (Validator.isNull(getLocalization(xml, defaultLanguageId))) {
430 String oldValue = PrefsParamUtil.getString(
431 preferences, portletRequest, parameter);
432
433 if (Validator.isNotNull(oldValue)) {
434 xml = updateLocalization(xml, parameter, oldValue);
435 }
436 }
437
438 return xml;
439 }
440
441 public Map<Locale, String> getLocalizedParameter(
442 PortletRequest portletRequest, String parameter) {
443
444 return getLocalizationMap(portletRequest, parameter);
445 }
446
447 public String getPreferencesKey(String key, String languageId) {
448 String defaultLanguageId = LocaleUtil.toLanguageId(
449 LocaleUtil.getDefault());
450
451 if (!languageId.equals(defaultLanguageId)) {
452 key += StringPool.UNDERLINE + languageId;
453 }
454
455 return key;
456 }
457
458 public String getPreferencesValue(
459 PortletPreferences preferences, String key, String languageId) {
460
461 return getPreferencesValue(preferences, key, languageId, true);
462 }
463
464 public String getPreferencesValue(
465 PortletPreferences preferences, String key, String languageId,
466 boolean useDefault) {
467
468 String localizedKey = getPreferencesKey(key, languageId);
469
470 String value = preferences.getValue(localizedKey, StringPool.BLANK);
471
472 if (useDefault && Validator.isNull(value)) {
473 value = preferences.getValue(key, StringPool.BLANK);
474 }
475
476 return value;
477 }
478
479 public String[] getPreferencesValues(
480 PortletPreferences preferences, String key, String languageId) {
481
482 return getPreferencesValues(preferences, key, languageId, true);
483 }
484
485 public String[] getPreferencesValues(
486 PortletPreferences preferences, String key, String languageId,
487 boolean useDefault) {
488
489 String localizedKey = getPreferencesKey(key, languageId);
490
491 String[] values = preferences.getValues(localizedKey, new String[0]);
492
493 if (useDefault && Validator.isNull(values)) {
494 values = preferences.getValues(key, new String[0]);
495 }
496
497 return values;
498 }
499
500 public String removeLocalization(
501 String xml, String key, String requestedLanguageId) {
502
503 return removeLocalization(xml, key, requestedLanguageId, false);
504 }
505
506 public String removeLocalization(
507 String xml, String key, String requestedLanguageId, boolean cdata) {
508
509 return removeLocalization(xml, key, requestedLanguageId, cdata, true);
510 }
511
512 public String removeLocalization(
513 String xml, String key, String requestedLanguageId, boolean cdata,
514 boolean localized) {
515
516 if (Validator.isNull(xml)) {
517 return StringPool.BLANK;
518 }
519
520 xml = _sanitizeXML(xml);
521
522 String systemDefaultLanguageId = LocaleUtil.toLanguageId(
523 LocaleUtil.getDefault());
524
525 XMLStreamReader xmlStreamReader = null;
526 XMLStreamWriter xmlStreamWriter = null;
527
528 ClassLoader portalClassLoader =
529 PACLClassLoaderUtil.getPortalClassLoader();
530
531 ClassLoader contextClassLoader =
532 PACLClassLoaderUtil.getContextClassLoader();
533
534 try {
535 if (contextClassLoader != portalClassLoader) {
536 PACLClassLoaderUtil.setContextClassLoader(portalClassLoader);
537 }
538
539 XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
540
541 xmlStreamReader = xmlInputFactory.createXMLStreamReader(
542 new UnsyncStringReader(xml));
543
544 String availableLocales = StringPool.BLANK;
545 String defaultLanguageId = StringPool.BLANK;
546
547
548
549 if (xmlStreamReader.hasNext()) {
550 xmlStreamReader.nextTag();
551
552 availableLocales = xmlStreamReader.getAttributeValue(
553 null, _AVAILABLE_LOCALES);
554 defaultLanguageId = xmlStreamReader.getAttributeValue(
555 null, _DEFAULT_LOCALE);
556
557 if (Validator.isNull(defaultLanguageId)) {
558 defaultLanguageId = systemDefaultLanguageId;
559 }
560 }
561
562 if ((availableLocales != null) &&
563 (availableLocales.indexOf(requestedLanguageId) != -1)) {
564
565 availableLocales = StringUtil.remove(
566 availableLocales, requestedLanguageId, StringPool.COMMA);
567
568 UnsyncStringWriter unsyncStringWriter =
569 new UnsyncStringWriter();
570
571 XMLOutputFactory xmlOutputFactory =
572 XMLOutputFactory.newInstance();
573
574 xmlStreamWriter = xmlOutputFactory.createXMLStreamWriter(
575 unsyncStringWriter);
576
577 xmlStreamWriter.writeStartDocument();
578 xmlStreamWriter.writeStartElement(_ROOT);
579
580 if (localized) {
581 xmlStreamWriter.writeAttribute(
582 _AVAILABLE_LOCALES, availableLocales);
583 xmlStreamWriter.writeAttribute(
584 _DEFAULT_LOCALE, defaultLanguageId);
585 }
586
587 _copyNonExempt(
588 xmlStreamReader, xmlStreamWriter, requestedLanguageId,
589 defaultLanguageId, cdata);
590
591 xmlStreamWriter.writeEndElement();
592 xmlStreamWriter.writeEndDocument();
593
594 xmlStreamWriter.close();
595 xmlStreamWriter = null;
596
597 xml = unsyncStringWriter.toString();
598 }
599 }
600 catch (Exception e) {
601 if (_log.isWarnEnabled()) {
602 _log.warn(e, e);
603 }
604 }
605 finally {
606 if (contextClassLoader != portalClassLoader) {
607 PACLClassLoaderUtil.setContextClassLoader(contextClassLoader);
608 }
609
610 if (xmlStreamReader != null) {
611 try {
612 xmlStreamReader.close();
613 }
614 catch (Exception e) {
615 }
616 }
617
618 if (xmlStreamWriter != null) {
619 try {
620 xmlStreamWriter.close();
621 }
622 catch (Exception e) {
623 }
624 }
625 }
626
627 return xml;
628 }
629
630 public void setLocalizedPreferencesValues(
631 PortletRequest portletRequest, PortletPreferences preferences,
632 String parameter)
633 throws Exception {
634
635 Map<Locale, String> map = getLocalizationMap(portletRequest, parameter);
636
637 for (Map.Entry<Locale, String> entry : map.entrySet()) {
638 String languageId = LocaleUtil.toLanguageId(entry.getKey());
639 String value = entry.getValue();
640
641 setPreferencesValue(preferences, parameter, languageId, value);
642 }
643 }
644
645 public void setPreferencesValue(
646 PortletPreferences preferences, String key, String languageId,
647 String value)
648 throws Exception {
649
650 preferences.setValue(getPreferencesKey(key, languageId), value);
651 }
652
653 public void setPreferencesValues(
654 PortletPreferences preferences, String key, String languageId,
655 String[] values)
656 throws Exception {
657
658 preferences.setValues(getPreferencesKey(key, languageId), values);
659 }
660
661 public String updateLocalization(String xml, String key, String value) {
662 String defaultLanguageId = LocaleUtil.toLanguageId(
663 LocaleUtil.getDefault());
664
665 return updateLocalization(
666 xml, key, value, defaultLanguageId, defaultLanguageId);
667 }
668
669 public String updateLocalization(
670 String xml, String key, String value, String requestedLanguageId) {
671
672 String defaultLanguageId = LocaleUtil.toLanguageId(
673 LocaleUtil.getDefault());
674
675 return updateLocalization(
676 xml, key, value, requestedLanguageId, defaultLanguageId);
677 }
678
679 public String updateLocalization(
680 String xml, String key, String value, String requestedLanguageId,
681 String defaultLanguageId) {
682
683 return updateLocalization(
684 xml, key, value, requestedLanguageId, defaultLanguageId, false);
685 }
686
687 public String updateLocalization(
688 String xml, String key, String value, String requestedLanguageId,
689 String defaultLanguageId, boolean cdata) {
690
691 return updateLocalization(
692 xml, key, value, requestedLanguageId, defaultLanguageId, cdata,
693 true);
694 }
695
696 public String updateLocalization(
697 String xml, String key, String value, String requestedLanguageId,
698 String defaultLanguageId, boolean cdata, boolean localized) {
699
700 xml = _sanitizeXML(xml);
701
702 XMLStreamReader xmlStreamReader = null;
703 XMLStreamWriter xmlStreamWriter = null;
704
705 ClassLoader portalClassLoader =
706 PACLClassLoaderUtil.getPortalClassLoader();
707
708 ClassLoader contextClassLoader =
709 PACLClassLoaderUtil.getContextClassLoader();
710
711 try {
712 if (contextClassLoader != portalClassLoader) {
713 PACLClassLoaderUtil.setContextClassLoader(portalClassLoader);
714 }
715
716 XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
717
718 xmlStreamReader = xmlInputFactory.createXMLStreamReader(
719 new UnsyncStringReader(xml));
720
721 String availableLocales = StringPool.BLANK;
722
723
724
725 if (xmlStreamReader.hasNext()) {
726 xmlStreamReader.nextTag();
727
728 availableLocales = xmlStreamReader.getAttributeValue(
729 null, _AVAILABLE_LOCALES);
730
731 if (Validator.isNull(availableLocales)) {
732 availableLocales = defaultLanguageId;
733 }
734
735 if (availableLocales.indexOf(requestedLanguageId) == -1) {
736 availableLocales = StringUtil.add(
737 availableLocales, requestedLanguageId,
738 StringPool.COMMA);
739 }
740 }
741
742 UnsyncStringWriter unsyncStringWriter = new UnsyncStringWriter();
743
744 XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance();
745
746 xmlStreamWriter = xmlOutputFactory.createXMLStreamWriter(
747 unsyncStringWriter);
748
749 xmlStreamWriter.writeStartDocument();
750 xmlStreamWriter.writeStartElement(_ROOT);
751
752 if (localized) {
753 xmlStreamWriter.writeAttribute(
754 _AVAILABLE_LOCALES, availableLocales);
755 xmlStreamWriter.writeAttribute(
756 _DEFAULT_LOCALE, defaultLanguageId);
757 }
758
759 _copyNonExempt(
760 xmlStreamReader, xmlStreamWriter, requestedLanguageId,
761 defaultLanguageId, cdata);
762
763 xmlStreamWriter.writeStartElement(key);
764
765 if (localized) {
766 xmlStreamWriter.writeAttribute(
767 _LANGUAGE_ID, requestedLanguageId);
768 }
769
770 if (cdata) {
771 xmlStreamWriter.writeCData(value);
772 }
773 else {
774 xmlStreamWriter.writeCharacters(value);
775 }
776
777 xmlStreamWriter.writeEndElement();
778 xmlStreamWriter.writeEndElement();
779 xmlStreamWriter.writeEndDocument();
780
781 xmlStreamWriter.close();
782 xmlStreamWriter = null;
783
784 xml = unsyncStringWriter.toString();
785 }
786 catch (Exception e) {
787 if (_log.isWarnEnabled()) {
788 _log.warn(e, e);
789 }
790 }
791 finally {
792 if (contextClassLoader != portalClassLoader) {
793 PACLClassLoaderUtil.setContextClassLoader(contextClassLoader);
794 }
795
796 if (xmlStreamReader != null) {
797 try {
798 xmlStreamReader.close();
799 }
800 catch (Exception e) {
801 }
802 }
803
804 if (xmlStreamWriter != null) {
805 try {
806 xmlStreamWriter.close();
807 }
808 catch (Exception e) {
809 }
810 }
811 }
812
813 return xml;
814 }
815
816 private void _copyNonExempt(
817 XMLStreamReader xmlStreamReader, XMLStreamWriter xmlStreamWriter,
818 String exemptLanguageId, String defaultLanguageId, boolean cdata)
819 throws XMLStreamException {
820
821 while (xmlStreamReader.hasNext()) {
822 int event = xmlStreamReader.next();
823
824 if (event == XMLStreamConstants.START_ELEMENT) {
825 String languageId = xmlStreamReader.getAttributeValue(
826 null, _LANGUAGE_ID);
827
828 if (Validator.isNull(languageId)) {
829 languageId = defaultLanguageId;
830 }
831
832 if (!languageId.equals(exemptLanguageId)) {
833 xmlStreamWriter.writeStartElement(
834 xmlStreamReader.getLocalName());
835 xmlStreamWriter.writeAttribute(_LANGUAGE_ID, languageId);
836
837 while (xmlStreamReader.hasNext()) {
838 event = xmlStreamReader.next();
839
840 if ((event == XMLStreamConstants.CHARACTERS) ||
841 (event == XMLStreamConstants.CDATA)) {
842
843 String text = xmlStreamReader.getText();
844
845 if (cdata) {
846 xmlStreamWriter.writeCData(text);
847 }
848 else {
849 xmlStreamWriter.writeCharacters(
850 xmlStreamReader.getText());
851 }
852
853 break;
854 }
855 else if (event == XMLStreamConstants.END_ELEMENT) {
856 break;
857 }
858 }
859
860 xmlStreamWriter.writeEndElement();
861 }
862 }
863 else if (event == XMLStreamConstants.END_DOCUMENT) {
864 break;
865 }
866 }
867 }
868
869 private String _getCachedValue(
870 String xml, String requestedLanguageId, boolean useDefault) {
871
872 String value = null;
873
874 Map<Tuple, String> valueMap = _cache.get(xml);
875
876 if (valueMap != null) {
877 Tuple subkey = new Tuple(useDefault, requestedLanguageId);
878
879 value = valueMap.get(subkey);
880 }
881
882 return value;
883 }
884
885 private String _getLocalization(
886 String bundleName, Locale locale, ClassLoader classLoader, String key,
887 String defaultValue) {
888
889 ResourceBundle resourceBundle = ResourceBundle.getBundle(
890 bundleName, locale, classLoader);
891
892 String value = null;
893
894 try {
895 value = resourceBundle.getString(key);
896
897 value = new String(
898 value.getBytes(StringPool.ISO_8859_1), StringPool.UTF8);
899 }
900
901 catch (Exception e) {
902 }
903
904 if (Validator.isNotNull(value)) {
905 value = LanguageResources.fixValue(value);
906 }
907 else {
908 value = LanguageUtil.get(locale, key, defaultValue);
909 }
910
911 return value;
912 }
913
914 private String _getRootAttribute(
915 String xml, String name, String defaultValue) {
916
917 String value = null;
918
919 XMLStreamReader xmlStreamReader = null;
920
921 ClassLoader portalClassLoader =
922 PACLClassLoaderUtil.getPortalClassLoader();
923
924 ClassLoader contextClassLoader =
925 PACLClassLoaderUtil.getContextClassLoader();
926
927 try {
928 if (contextClassLoader != portalClassLoader) {
929 PACLClassLoaderUtil.setContextClassLoader(portalClassLoader);
930 }
931
932 XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
933
934 xmlStreamReader = xmlInputFactory.createXMLStreamReader(
935 new UnsyncStringReader(xml));
936
937 if (xmlStreamReader.hasNext()) {
938 xmlStreamReader.nextTag();
939
940 value = xmlStreamReader.getAttributeValue(null, name);
941 }
942 }
943 catch (Exception e) {
944 if (_log.isWarnEnabled()) {
945 _log.warn(e, e);
946 }
947 }
948 finally {
949 if (contextClassLoader != portalClassLoader) {
950 PACLClassLoaderUtil.setContextClassLoader(contextClassLoader);
951 }
952
953 if (xmlStreamReader != null) {
954 try {
955 xmlStreamReader.close();
956 }
957 catch (Exception e) {
958 }
959 }
960 }
961
962 if (Validator.isNull(value)) {
963 value = defaultValue;
964 }
965
966 return value;
967 }
968
969 private String _sanitizeXML(String xml) {
970 if (Validator.isNull(xml) || (xml.indexOf("<root") == -1)) {
971 xml = _EMPTY_ROOT_NODE;
972 }
973
974 return xml;
975 }
976
977 private void _setCachedValue(
978 String xml, String requestedLanguageId, boolean useDefault,
979 String value) {
980
981 if (Validator.isNotNull(xml) && !xml.equals(_EMPTY_ROOT_NODE)) {
982 synchronized (_cache) {
983 Map<Tuple, String> map = _cache.get(xml);
984
985 if (map == null) {
986 map = new HashMap<Tuple, String>();
987 }
988
989 Tuple subkey = new Tuple(useDefault, requestedLanguageId);
990
991 map.put(subkey, value);
992
993 _cache.put(xml, map);
994 }
995 }
996 }
997
998 private static final String _AVAILABLE_LOCALES = "available-locales";
999
1000 private static final String _DEFAULT_LOCALE = "default-locale";
1001
1002 private static final String _EMPTY_ROOT_NODE = "<root />";
1003
1004 private static final String _LANGUAGE_ID = "language-id";
1005
1006 private static final String _ROOT = "root";
1007
1008 private static Log _log = LogFactoryUtil.getLog(LocalizationImpl.class);
1009
1010 private Map<String, Map<Tuple, String>> _cache = new ReferenceMap(
1011 ReferenceMap.SOFT, ReferenceMap.HARD);
1012
1013 }