static {
_allMediaGalleryMimeTypes.addAll(
SetUtil.fromArray(PropsUtil.getArray(PropsKeys.DL_FILE_ENTRY_PREVIEW_AUDIO_MIME_TYPES)));
_allMediaGalleryMimeTypes.addAll(
SetUtil.fromArray(PropsUtil.getArray(PropsKeys.DL_FILE_ENTRY_PREVIEW_VIDEO_MIME_TYPES)));
_allMediaGalleryMimeTypes.addAll(
SetUtil.fromArray(PropsUtil.getArray(PropsKeys.DL_FILE_ENTRY_PREVIEW_IMAGE_MIME_TYPES)));
_allMediaGalleryMimeTypesString = StringUtil.merge(_allMediaGalleryMimeTypes);
String[] fileIcons = null;
try {
fileIcons = PropsUtil.getArray(PropsKeys.DL_FILE_ICONS);
} catch (Exception e) {
if (_log.isDebugEnabled()) {
_log.debug(e, e);
}
fileIcons = new String[] {StringPool.BLANK};
}
for (int i = 0; i < fileIcons.length; i++) {
// Only process non wildcard extensions
if (!StringPool.STAR.equals(fileIcons[i])) {
// Strip starting period
String extension = fileIcons[i];
if (extension.length() > 0) {
extension = extension.substring(1);
}
_fileIcons.add(extension);
}
}
String[] genericNames = PropsUtil.getArray(PropsKeys.DL_FILE_GENERIC_NAMES);
for (String genericName : genericNames) {
_populateGenericNamesMap(genericName);
}
}
private void _populateGenericNamesMap(String genericName) {
String[] extensions =
PropsUtil.getArray(PropsKeys.DL_FILE_GENERIC_EXTENSIONS, new Filter(genericName));
for (String extension : extensions) {
_genericNames.put(extension, genericName);
}
}
protected void indexKeywords(
long companyId,
String languageId,
String propsKey,
String keywordFieldName,
String typeFieldValue,
int maxNGramLength)
throws Exception {
String[] dictionaryFileNames = PropsUtil.getArray(propsKey, new Filter(languageId));
indexKeywords(
companyId,
0,
languageId,
dictionaryFileNames,
keywordFieldName,
typeFieldValue,
maxNGramLength);
List<Group> groups = GroupLocalServiceUtil.getLiveGroups();
for (Group group : groups) {
String[] groupDictionaryFileNames =
PropsUtil.getArray(
PropsKeys.INDEX_SEARCH_SPELL_CHECKER_DICTIONARY,
new Filter(languageId, String.valueOf(group.getGroupId())));
if (ArrayUtil.isEmpty(groupDictionaryFileNames)) {
continue;
}
indexKeywords(
companyId,
group.getGroupId(),
languageId,
dictionaryFileNames,
keywordFieldName,
typeFieldValue,
maxNGramLength);
}
}
/** @author Alexander Chow */
public class JournalArticleConstants {
public static final String CANONICAL_URL_SEPARATOR = "/-/";
public static final double DEFAULT_VERSION = 1.0;
public static final String PORTLET = "portlet";
public static final String STAND_ALONE = "stand-alone";
public static final String[] TYPES = PropsUtil.getArray(PropsKeys.JOURNAL_ARTICLE_TYPES);
}
public String getSocialBookmarksDisplayStyle() {
if (_socialBookmarksDisplayStyle == null) {
_socialBookmarksDisplayStyle =
_portletPreferences.getValue("socialBookmarksDisplayStyle", null);
if (Validator.isNull(_socialBookmarksDisplayStyle)) {
String[] socialBookmarksDisplayStyles =
PropsUtil.getArray(PropsKeys.SOCIAL_BOOKMARK_DISPLAY_STYLES);
_socialBookmarksDisplayStyle = socialBookmarksDisplayStyles[0];
}
}
return _socialBookmarksDisplayStyle;
}
/**
* @author Brian Wing Shun Chan
* @author Bruno Farache
*/
public class DocumentImpl implements Document {
public static String getLocalizedName(Locale locale, String name) {
if (locale == null) {
return name;
}
String languageId = LocaleUtil.toLanguageId(locale);
return getLocalizedName(languageId, name);
}
public static String getLocalizedName(String languageId, String name) {
return LocalizationUtil.getLocalizedName(name, languageId);
}
public static String getSortableFieldName(String name) {
return name.concat(StringPool.UNDERLINE).concat(_SORTABLE_FIELD_SUFFIX);
}
public static String getSortFieldName(Sort sort, String scoreFieldName) {
if (sort.getType() == Sort.SCORE_TYPE) {
return scoreFieldName;
}
String fieldName = sort.getFieldName();
if (DocumentImpl.isSortableFieldName(fieldName)) {
return fieldName;
}
if ((sort.getType() == Sort.STRING_TYPE) && !DocumentImpl.isSortableTextField(fieldName)) {
return scoreFieldName;
}
return DocumentImpl.getSortableFieldName(fieldName);
}
public static boolean isSortableFieldName(String name) {
return name.endsWith(_SORTABLE_FIELD_SUFFIX);
}
public static boolean isSortableTextField(String name) {
return _defaultSortableTextFields.contains(name);
}
@Override
public void add(Field field) {
_fields.put(field.getName(), field);
}
@Override
public void addDate(String name, Date value) {
if (value == null) {
return;
}
addDate(name, new Date[] {value});
}
@Override
public void addDate(String name, Date[] values) {
if (values == null) {
return;
}
if (_dateFormat == null) {
_dateFormat = FastDateFormatFactoryUtil.getSimpleDateFormat(_INDEX_DATE_FORMAT_PATTERN);
}
String[] datesString = new String[values.length];
Long[] datesTime = new Long[values.length];
for (int i = 0; i < values.length; i++) {
datesString[i] = _dateFormat.format(values[i]);
datesTime[i] = values[i].getTime();
}
createSortableNumericField(name, false, datesTime);
Field field = createField(name, datesString);
field.setDates(values);
}
@Override
public void addDateSortable(String name, Date value) {
if (value == null) {
return;
}
addDateSortable(name, new Date[] {value});
}
@Override
public void addDateSortable(String name, Date[] values) {
if (values == null) {
return;
}
String[] datesString = new String[values.length];
Long[] datesTime = new Long[values.length];
for (int i = 0; i < values.length; i++) {
datesString[i] = _dateFormat.format(values[i]);
datesTime[i] = values[i].getTime();
}
createSortableNumericField(name, true, datesTime);
addKeyword(name, datesString);
}
@Override
public void addFile(String name, byte[] bytes, String fileExt) {
InputStream is = new UnsyncByteArrayInputStream(bytes);
addFile(name, is, fileExt);
}
@Override
public void addFile(String name, File file, String fileExt) throws IOException {
InputStream is = new FileInputStream(file);
addFile(name, is, fileExt);
}
@Override
public void addFile(String name, InputStream is, String fileExt) {
addText(name, FileUtil.extractText(is, fileExt));
}
@Override
public void addFile(String name, InputStream is, String fileExt, int maxStringLength) {
addText(name, FileUtil.extractText(is, fileExt, maxStringLength));
}
@Override
public void addGeoLocation(double latitude, double longitude) {
addGeoLocation(Field.GEO_LOCATION, latitude, longitude);
}
@Override
public void addGeoLocation(String name, double latitude, double longitude) {
Field field = new Field(name);
field.setGeoLocationPoint(new GeoLocationPoint(latitude, longitude));
add(field);
}
@Override
public void addKeyword(String name, boolean value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, Boolean value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, boolean[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, Boolean[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, double value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, Double value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, double[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, Double[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, float value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, Float value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, float[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, Float[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, int value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, int[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, Integer value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, Integer[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, long value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, Long value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, long[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, Long[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, short value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, Short value) {
addKeyword(name, String.valueOf(value));
}
@Override
public void addKeyword(String name, short[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, Short[] values) {
if (values == null) {
return;
}
addKeyword(name, ArrayUtil.toStringArray(values));
}
@Override
public void addKeyword(String name, String value) {
addKeyword(name, value, false);
}
@Override
public void addKeyword(String name, String value, boolean lowerCase) {
createKeywordField(name, value, lowerCase);
createSortableKeywordField(name, value);
}
@Override
public void addKeyword(String name, String[] values) {
if (values == null) {
return;
}
createField(name, values);
}
@Override
public void addKeywordSortable(String name, Boolean value) {
String valueString = String.valueOf(value);
createKeywordField(name, valueString, false);
createSortableTextField(name, valueString);
}
@Override
public void addKeywordSortable(String name, Boolean[] values) {
if (values == null) {
return;
}
String[] valuesString = ArrayUtil.toStringArray(values);
createField(name, valuesString);
createSortableTextField(name, valuesString);
}
@Override
public void addKeywordSortable(String name, String value) {
createKeywordField(name, value, false);
createSortableTextField(name, value);
}
@Override
public void addKeywordSortable(String name, String[] values) {
createField(name, values);
createSortableTextField(name, values);
}
@Override
public void addLocalizedKeyword(String name, Map<Locale, String> values) {
addLocalizedKeyword(name, values, false);
}
@Override
public void addLocalizedKeyword(String name, Map<Locale, String> values, boolean lowerCase) {
if ((values == null) || values.isEmpty()) {
return;
}
if (lowerCase) {
Map<Locale, String> lowerCaseValues = new HashMap<>(values.size());
for (Map.Entry<Locale, String> entry : values.entrySet()) {
String value = GetterUtil.getString(entry.getValue());
lowerCaseValues.put(entry.getKey(), StringUtil.toLowerCase(value));
}
values = lowerCaseValues;
}
createField(name, values);
}
@Override
public void addLocalizedKeyword(
String name, Map<Locale, String> values, boolean lowerCase, boolean sortable) {
if ((values == null) || values.isEmpty()) {
return;
}
if (lowerCase) {
Map<Locale, String> lowerCaseValues = new HashMap<>(values.size());
for (Map.Entry<Locale, String> entry : values.entrySet()) {
String value = GetterUtil.getString(entry.getValue());
lowerCaseValues.put(entry.getKey(), StringUtil.toLowerCase(value));
}
values = lowerCaseValues;
}
createField(name, values, sortable);
}
@Override
public void addLocalizedText(String name, Map<Locale, String> values) {
if ((values == null) || values.isEmpty()) {
return;
}
Field field = createField(name, values);
field.setTokenized(true);
}
@Override
public void addNumber(String name, BigDecimal value) {
createNumberField(name, value);
}
@Override
public void addNumber(String name, BigDecimal[] values) {
createNumberField(name, values);
}
@Override
public void addNumber(String name, double value) {
createNumberField(name, Double.valueOf(value));
}
@Override
public void addNumber(String name, Double value) {
createNumberField(name, value);
}
@Override
public void addNumber(String name, double[] values) {
if (values == null) {
return;
}
createNumberField(name, ArrayUtil.toArray(values));
}
@Override
public void addNumber(String name, Double[] values) {
createNumberField(name, values);
}
@Override
public void addNumber(String name, float value) {
createNumberField(name, Float.valueOf(value));
}
@Override
public void addNumber(String name, Float value) {
createNumberField(name, value);
}
@Override
public void addNumber(String name, float[] values) {
if (values == null) {
return;
}
createNumberField(name, ArrayUtil.toArray(values));
}
@Override
public void addNumber(String name, Float[] values) {
createNumberField(name, values);
}
@Override
public void addNumber(String name, int value) {
createNumberField(name, Integer.valueOf(value));
}
@Override
public void addNumber(String name, int[] values) {
if (values == null) {
return;
}
createNumberField(name, ArrayUtil.toArray(values));
}
@Override
public void addNumber(String name, Integer value) {
createNumberField(name, value);
}
@Override
public void addNumber(String name, Integer[] values) {
createNumberField(name, values);
}
@Override
public void addNumber(String name, long value) {
createNumberField(name, Long.valueOf(value));
}
@Override
public void addNumber(String name, Long value) {
createNumberField(name, value);
}
@Override
public void addNumber(String name, long[] values) {
if (values == null) {
return;
}
createNumberField(name, ArrayUtil.toArray(values));
}
@Override
public void addNumber(String name, Long[] values) {
createNumberField(name, values);
}
@Override
public void addNumber(String name, String value) {
createNumberField(name, Long.valueOf(value));
}
@Override
public void addNumber(String name, String[] values) {
if (values == null) {
return;
}
Long[] longs = new Long[values.length];
for (int i = 0; i < values.length; i++) {
longs[i] = Long.valueOf(values[i]);
}
createNumberField(name, longs);
}
@Override
public void addNumberSortable(String name, BigDecimal value) {
createNumberFieldWithTypedSortable(name, value);
}
@Override
public void addNumberSortable(String name, BigDecimal[] values) {
createNumberFieldWithTypedSortable(name, values);
}
@Override
public void addNumberSortable(String name, Double value) {
createNumberFieldWithTypedSortable(name, value);
}
@Override
public void addNumberSortable(String name, Double[] values) {
createNumberFieldWithTypedSortable(name, values);
}
@Override
public void addNumberSortable(String name, Float value) {
createNumberFieldWithTypedSortable(name, value);
}
@Override
public void addNumberSortable(String name, Float[] values) {
createNumberFieldWithTypedSortable(name, values);
}
@Override
public void addNumberSortable(String name, Integer value) {
createNumberFieldWithTypedSortable(name, value);
}
@Override
public void addNumberSortable(String name, Integer[] values) {
createNumberFieldWithTypedSortable(name, values);
}
@Override
public void addNumberSortable(String name, Long value) {
createNumberFieldWithTypedSortable(name, value);
}
@Override
public void addNumberSortable(String name, Long[] values) {
createNumberFieldWithTypedSortable(name, values);
}
@Override
public void addText(String name, String value) {
if (Validator.isNull(value)) {
return;
}
Field field = createField(name, value);
field.setTokenized(true);
createSortableKeywordField(name, value);
}
@Override
public void addText(String name, String[] values) {
if (values == null) {
return;
}
Field field = createField(name, values);
field.setTokenized(true);
createSortableKeywordField(name, values);
}
@Override
public void addTextSortable(String name, String value) {
if (Validator.isNull(value)) {
return;
}
Field field = createField(name, value);
field.setTokenized(true);
createSortableTextField(name, value);
}
@Override
public void addTextSortable(String name, String[] values) {
if (values == null) {
return;
}
Field field = createField(name, values);
field.setTokenized(true);
createSortableTextField(name, values);
}
@Override
public void addUID(String portletId, long field1) {
addUID(portletId, String.valueOf(field1));
}
@Override
public void addUID(String portletId, long field1, String field2) {
addUID(portletId, String.valueOf(field1), field2);
}
@Override
public void addUID(String portletId, Long field1) {
addUID(portletId, field1.longValue());
}
@Override
public void addUID(String portletId, Long field1, String field2) {
addUID(portletId, field1.longValue(), field2);
}
@Override
public void addUID(String portletId, String field1) {
addUID(portletId, field1, null);
}
@Override
public void addUID(String portletId, String field1, String field2) {
addUID(portletId, field1, field2, null);
}
@Override
public void addUID(String portletId, String field1, String field2, String field3) {
addUID(portletId, field1, field2, field3, null);
}
@Override
public void addUID(String portletId, String field1, String field2, String field3, String field4) {
String uid = portletId + _UID_PORTLET + field1;
if (field2 != null) {
uid += _UID_FIELD + field2;
}
if (field3 != null) {
uid += _UID_FIELD + field3;
}
if (field4 != null) {
uid += _UID_FIELD + field4;
}
addKeyword(Field.UID, uid);
}
@Override
public Object clone() {
DocumentImpl documentImpl = new DocumentImpl();
documentImpl.setSortableTextFields(_sortableTextFields);
return documentImpl;
}
@Override
public String get(Locale locale, String name) {
if (locale == null) {
return get(name);
}
String localizedName = getLocalizedName(locale, name);
Field field = getField(localizedName);
if (field == null) {
field = getField(name);
}
if (field == null) {
return StringPool.BLANK;
}
return field.getValue();
}
@Override
public String get(Locale locale, String name, String defaultName) {
if (locale == null) {
return get(name, defaultName);
}
String localizedName = getLocalizedName(locale, name);
Field field = getField(localizedName);
if (field == null) {
localizedName = getLocalizedName(locale, defaultName);
field = getField(localizedName);
}
if (field == null) {
return StringPool.BLANK;
}
return field.getValue();
}
@Override
public String get(String name) {
Field field = getField(name);
if (field == null) {
return StringPool.BLANK;
}
return field.getValue();
}
@Override
public String get(String name, String defaultName) {
Field field = getField(name);
if (field == null) {
return get(defaultName);
}
return field.getValue();
}
@Override
public Date getDate(String name) throws ParseException {
DateFormat dateFormat = DateFormatFactoryUtil.getSimpleDateFormat(_INDEX_DATE_FORMAT_PATTERN);
return dateFormat.parse(get(name));
}
@Override
public Field getField(String name) {
return doGetField(name, false);
}
@Override
public Map<String, Field> getFields() {
return _fields;
}
@Override
public String getPortletId() {
String uid = getUID();
int pos = uid.indexOf(_UID_PORTLET);
return uid.substring(0, pos);
}
@Override
public String getUID() {
Field field = getField(Field.UID);
if (field == null) {
throw new RuntimeException("UID is not set");
}
return field.getValue();
}
@Override
public String[] getValues(String name) {
Field field = getField(name);
if (field == null) {
return new String[] {StringPool.BLANK};
}
return field.getValues();
}
@Override
public boolean hasField(String name) {
if (_fields.containsKey(name)) {
return true;
}
return false;
}
@Override
public boolean isDocumentSortableTextField(String name) {
return _sortableTextFields.contains(name);
}
@Override
public void remove(String name) {
_fields.remove(name);
}
public void setFields(Map<String, Field> fields) {
_fields = fields;
}
@Override
public void setSortableTextFields(String[] sortableTextFields) {
_sortableTextFields = SetUtil.fromArray(sortableTextFields);
}
@Override
public String toString() {
StringBundler sb = new StringBundler(5 * _fields.size());
toString(sb, _fields.values());
return sb.toString();
}
protected Field createField(String name) {
return doGetField(name, true);
}
protected Field createField(String name, boolean sortable, String... values) {
Field field = createField(name);
field.setSortable(sortable);
field.setValues(values);
return field;
}
protected Field createField(String name, Map<Locale, String> localizedValues) {
return createField(name, localizedValues, false);
}
protected Field createField(String name, Map<Locale, String> localizedValues, boolean sortable) {
Field field = createField(name);
field.setLocalizedValues(localizedValues);
field.setSortable(sortable);
return field;
}
protected Field createField(String name, String... values) {
return createField(name, false, values);
}
protected void createKeywordField(String name, String value, boolean lowerCase) {
if (lowerCase && Validator.isNotNull(value)) {
value = StringUtil.toLowerCase(value);
}
createField(name, value);
}
protected void createNumberField(String name, boolean typify, Number value) {
if (value == null) {
return;
}
String valueString = String.valueOf(value);
createSortableNumericField(name, typify, valueString, value.getClass());
createField(name, valueString);
}
protected <T extends Number & Comparable<? super T>> void createNumberField(
String name, boolean typify, T... values) {
if (values == null) {
return;
}
createSortableNumericField(name, typify, values);
createField(name, ArrayUtil.toStringArray(values));
}
protected void createNumberField(String name, Number value) {
createNumberField(name, false, value);
}
protected <T extends Number & Comparable<? super T>> void createNumberField(
String name, T... values) {
createNumberField(name, false, values);
}
protected void createNumberFieldWithTypedSortable(String name, Number value) {
createNumberField(name, true, value);
}
protected <T extends Number & Comparable<? super T>> void createNumberFieldWithTypedSortable(
String name, T... values) {
createNumberField(name, true, values);
}
protected void createSortableKeywordField(String name, String value) {
if (isDocumentSortableTextField(name)) {
createSortableTextField(name, value);
}
}
protected void createSortableKeywordField(String name, String[] values) {
if (isDocumentSortableTextField(name)) {
createSortableTextField(name, values);
}
}
protected void createSortableNumericField(
String name, boolean typify, String value, Class<? extends Number> clazz) {
if (typify) {
name = name.concat(StringPool.UNDERLINE).concat("Number");
}
Field field = createField(getSortableFieldName(name), value);
field.setNumeric(true);
field.setNumericClass(clazz);
}
protected <T extends Number & Comparable<? super T>> void createSortableNumericField(
String name, boolean typify, T... values) {
if ((values == null) || (values.length == 0)) {
return;
}
T minValue = Collections.min(Arrays.asList(values));
createSortableNumericField(name, typify, String.valueOf(minValue), minValue.getClass());
}
protected void createSortableTextField(String name, String value) {
String truncatedValue = value;
if (value.length() > _SORTABLE_TEXT_FIELDS_TRUNCATED_LENGTH) {
truncatedValue = value.substring(0, _SORTABLE_TEXT_FIELDS_TRUNCATED_LENGTH);
}
createKeywordField(getSortableFieldName(name), truncatedValue, true);
}
protected void createSortableTextField(String name, String[] values) {
if (values.length == 0) {
return;
}
createSortableTextField(name, Collections.min(Arrays.asList(values)));
}
protected Field doGetField(String name, boolean createIfNew) {
Field field = _fields.get(name);
if ((field == null) && createIfNew) {
field = new Field(name);
_fields.put(name, field);
}
return field;
}
protected void setSortableTextFields(Set<String> sortableTextFields) {
_sortableTextFields = sortableTextFields;
}
protected void toString(StringBundler sb, Collection<Field> fields) {
sb.append(StringPool.OPEN_CURLY_BRACE);
boolean firstField = true;
for (Field field : fields) {
if (!firstField) {
sb.append(StringPool.COMMA);
sb.append(StringPool.SPACE);
} else {
firstField = false;
}
if (field.hasChildren()) {
sb.append(field.getName());
sb.append(StringPool.COLON);
toString(sb, field.getFields());
} else {
sb.append(field.getName());
sb.append(StringPool.EQUAL);
sb.append(Arrays.toString(field.getValues()));
}
}
sb.append(StringPool.CLOSE_CURLY_BRACE);
}
private static final String _INDEX_DATE_FORMAT_PATTERN =
PropsUtil.get(PropsKeys.INDEX_DATE_FORMAT_PATTERN);
private static final String _SORTABLE_FIELD_SUFFIX = "sortable";
private static final int _SORTABLE_TEXT_FIELDS_TRUNCATED_LENGTH =
GetterUtil.getInteger(PropsUtil.get(PropsKeys.INDEX_SORTABLE_TEXT_FIELDS_TRUNCATED_LENGTH));
private static final String _UID_FIELD = "_FIELD_";
private static final String _UID_PORTLET = "_PORTLET_";
private static Format _dateFormat;
private static final Set<String> _defaultSortableTextFields =
SetUtil.fromArray(PropsUtil.getArray(PropsKeys.INDEX_SORTABLE_TEXT_FIELDS));
private Map<String, Field> _fields = new HashMap<>();
private Set<String> _sortableTextFields = _defaultSortableTextFields;
}
/** @author Mika Koivisto */
public class DLProcessorRegistryImpl implements DLProcessorRegistry {
public void cleanUp(FileEntry fileEntry) {
if (!DLProcessorThreadLocal.isEnabled()) {
return;
}
for (String dlProcessorClassName : _DL_FILE_ENTRY_PROCESSORS) {
DLProcessor dlProcessor = (DLProcessor) InstancePool.get(dlProcessorClassName);
dlProcessor.cleanUp(fileEntry);
}
for (DLProcessor dlProcessor : _dlProcessors) {
dlProcessor.cleanUp(fileEntry);
}
}
public void cleanUp(FileVersion fileVersion) {
if (!DLProcessorThreadLocal.isEnabled()) {
return;
}
for (String dlProcessorClassName : _DL_FILE_ENTRY_PROCESSORS) {
DLProcessor dlProcessor = (DLProcessor) InstancePool.get(dlProcessorClassName);
dlProcessor.cleanUp(fileVersion);
}
for (DLProcessor dlProcessor : _dlProcessors) {
dlProcessor.cleanUp(fileVersion);
}
}
public void exportGeneratedFiles(
PortletDataContext portletDataContext, FileEntry fileEntry, Element fileEntryElement)
throws Exception {
if ((fileEntry == null) || (fileEntry.getSize() == 0)) {
return;
}
FileVersion latestFileVersion = _getLatestFileVersion(fileEntry);
if (latestFileVersion == null) {
return;
}
for (String dlProcessorClassName : _DL_FILE_ENTRY_PROCESSORS) {
DLProcessor dlProcessor = (DLProcessor) InstancePool.get(dlProcessorClassName);
if (dlProcessor.isSupported(latestFileVersion)) {
dlProcessor.exportGeneratedFiles(portletDataContext, fileEntry, fileEntryElement);
}
}
for (DLProcessor dlProcessor : _dlProcessors) {
if (dlProcessor.isSupported(latestFileVersion)) {
dlProcessor.exportGeneratedFiles(portletDataContext, fileEntry, fileEntryElement);
}
}
}
public void importGeneratedFiles(
PortletDataContext portletDataContext,
FileEntry fileEntry,
FileEntry importedFileEntry,
Element fileEntryElement)
throws Exception {
if ((importedFileEntry == null) || (importedFileEntry.getSize() == 0)) {
return;
}
FileVersion fileVersion = importedFileEntry.getFileVersion();
if (fileVersion == null) {
return;
}
for (String dlProcessorClassName : _DL_FILE_ENTRY_PROCESSORS) {
DLProcessor dlProcessor = (DLProcessor) InstancePool.get(dlProcessorClassName);
if (dlProcessor.isSupported(fileVersion)) {
dlProcessor.importGeneratedFiles(
portletDataContext, fileEntry, importedFileEntry, fileEntryElement);
}
}
for (DLProcessor dlProcessor : _dlProcessors) {
if (dlProcessor.isSupported(fileVersion)) {
dlProcessor.importGeneratedFiles(
portletDataContext, fileEntry, importedFileEntry, fileEntryElement);
}
}
}
public void register(DLProcessor dlProcessor) {
_dlProcessors.add(dlProcessor);
}
public void trigger(FileEntry fileEntry) {
if (!DLProcessorThreadLocal.isEnabled()) {
return;
}
if ((fileEntry == null) || (fileEntry.getSize() == 0)) {
return;
}
FileVersion latestFileVersion = _getLatestFileVersion(fileEntry);
if (latestFileVersion == null) {
return;
}
for (String dlProcessorClassName : _DL_FILE_ENTRY_PROCESSORS) {
DLProcessor dlProcessor = (DLProcessor) InstancePool.get(dlProcessorClassName);
if (dlProcessor.isSupported(latestFileVersion)) {
dlProcessor.trigger(latestFileVersion);
}
}
for (DLProcessor dlProcessor : _dlProcessors) {
if (dlProcessor.isSupported(latestFileVersion)) {
dlProcessor.trigger(latestFileVersion);
}
}
}
public void unregister(DLProcessor dlProcessor) {
ListUtil.remove(_dlProcessors, dlProcessor);
}
private FileVersion _getLatestFileVersion(FileEntry fileEntry) {
FileVersion latestFileVersion = null;
try {
if (fileEntry.getModel() instanceof DLFileEntry) {
DLFileEntry dlFileEntry = (DLFileEntry) fileEntry.getModel();
latestFileVersion = new LiferayFileVersion(dlFileEntry.getLatestFileVersion(false));
} else {
latestFileVersion = fileEntry.getLatestFileVersion();
}
return latestFileVersion;
} catch (Exception e) {
_log.error(e, e);
return null;
}
}
private static final String[] _DL_FILE_ENTRY_PROCESSORS =
PropsUtil.getArray(PropsKeys.DL_FILE_ENTRY_PROCESSORS);
private static Log _log = LogFactoryUtil.getLog(DLProcessorRegistryImpl.class);
private List<DLProcessor> _dlProcessors = new CopyOnWriteArrayList<DLProcessor>();
}
/**
* @author Brian Wing Shun Chan
* @author Miguel Pastor
*/
public class PortletURLUtil {
public static PortletURL clone(
LiferayPortletURL liferayPortletURL, String lifecycle, MimeResponse mimeResponse)
throws PortletException {
LiferayPortletURL newURLImpl = null;
if (lifecycle.equals(PortletRequest.ACTION_PHASE)) {
newURLImpl = (LiferayPortletURL) mimeResponse.createActionURL();
} else if (lifecycle.equals(PortletRequest.RENDER_PHASE)) {
newURLImpl = (LiferayPortletURL) mimeResponse.createRenderURL();
}
newURLImpl.setPortletId(liferayPortletURL.getPortletId());
WindowState windowState = liferayPortletURL.getWindowState();
if (windowState != null) {
newURLImpl.setWindowState(windowState);
}
PortletMode portletMode = liferayPortletURL.getPortletMode();
if (portletMode != null) {
newURLImpl.setPortletMode(portletMode);
}
newURLImpl.setParameters(liferayPortletURL.getParameterMap());
return newURLImpl;
}
public static PortletURL clone(PortletURL portletURL, MimeResponse mimeResponse)
throws PortletException {
LiferayPortletURL liferayPortletURL = (LiferayPortletURL) portletURL;
return clone(liferayPortletURL, liferayPortletURL.getLifecycle(), mimeResponse);
}
public static PortletURL clone(PortletURL portletURL, String lifecycle, MimeResponse mimeResponse)
throws PortletException {
LiferayPortletURL liferayPortletURL = (LiferayPortletURL) portletURL;
return clone(liferayPortletURL, lifecycle, mimeResponse);
}
public static PortletURL getCurrent(PortletRequest portletRequest, MimeResponse mimeResponse) {
PortletURL portletURL = mimeResponse.createRenderURL();
Enumeration<String> enu = portletRequest.getParameterNames();
while (enu.hasMoreElements()) {
String param = enu.nextElement();
String[] values = portletRequest.getParameterValues(param);
boolean addParam = true;
// Don't set paramter values that are over 32 kb. See LEP-1755.
for (int i = 0; i < values.length; i++) {
if (values[i].length() > _CURRENT_URL_PARAMETER_THRESHOLD) {
addParam = false;
break;
}
}
if (addParam) {
portletURL.setParameter(param, values);
}
}
return portletURL;
}
public static String getRefreshURL(HttpServletRequest request, ThemeDisplay themeDisplay) {
StringBundler sb = new StringBundler(32);
sb.append(themeDisplay.getPathMain());
sb.append("/portal/render_portlet?p_l_id=");
long plid = themeDisplay.getPlid();
sb.append(plid);
Portlet portlet = (Portlet) request.getAttribute(WebKeys.RENDER_PORTLET);
String portletId = portlet.getPortletId();
sb.append("&p_p_id=");
sb.append(portletId);
sb.append("&p_p_lifecycle=0&p_t_lifecycle=");
sb.append(themeDisplay.getLifecycle());
WindowState windowState = WindowState.NORMAL;
if (themeDisplay.isStatePopUp()) {
windowState = LiferayWindowState.POP_UP;
} else {
LayoutTypePortlet layoutTypePortlet = themeDisplay.getLayoutTypePortlet();
if (layoutTypePortlet.hasStateMaxPortletId(portletId)) {
windowState = WindowState.MAXIMIZED;
} else if (layoutTypePortlet.hasStateMinPortletId(portletId)) {
windowState = WindowState.MINIMIZED;
}
}
sb.append("&p_p_state=");
sb.append(windowState);
sb.append("&p_p_mode=view&p_p_col_id=");
String columnId = (String) request.getAttribute(WebKeys.RENDER_PORTLET_COLUMN_ID);
sb.append(columnId);
Integer columnPos = (Integer) request.getAttribute(WebKeys.RENDER_PORTLET_COLUMN_POS);
sb.append("&p_p_col_pos=");
sb.append(columnPos);
Integer columnCount = (Integer) request.getAttribute(WebKeys.RENDER_PORTLET_COLUMN_COUNT);
sb.append("&p_p_col_count=");
sb.append(columnCount);
if (portlet.isStatic()) {
sb.append("&p_p_static=1");
if (portlet.isStaticStart()) {
sb.append("&p_p_static_start=1");
}
}
sb.append("&p_p_isolated=1");
String doAsUserId = themeDisplay.getDoAsUserId();
if (Validator.isNotNull(doAsUserId)) {
sb.append("&doAsUserId=");
sb.append(HttpUtil.encodeURL(doAsUserId));
}
String currentURL = PortalUtil.getCurrentURL(request);
sb.append("¤tURL=");
sb.append(HttpUtil.encodeURL(currentURL));
String ppid = ParamUtil.getString(request, "p_p_id");
if (ppid.equals(portletId)) {
String namespace = PortalUtil.getPortletNamespace(portletId);
Map<String, String[]> parameters = request.getParameterMap();
for (Map.Entry<String, String[]> entry : parameters.entrySet()) {
String name = entry.getKey();
if (!PortalUtil.isReservedParameter(name)
&& !name.equals("currentURL")
&& !isRefreshURLReservedParameter(name, namespace)) {
String[] values = entry.getValue();
for (int i = 0; i < values.length; i++) {
sb.append(StringPool.AMPERSAND);
sb.append(name);
sb.append(StringPool.EQUAL);
sb.append(HttpUtil.encodeURL(values[i]));
}
}
}
}
String outerPortletId = PortalUtil.getOuterPortletId(request);
if (outerPortletId != null) {
sb.append(StringPool.AMPERSAND);
sb.append("p_o_p_id");
sb.append(StringPool.EQUAL);
sb.append(HttpUtil.encodeURL(outerPortletId));
}
return sb.toString();
}
protected static boolean isRefreshURLReservedParameter(String parameter, String namespace) {
if ((_PORTLET_URL_REFRESH_URL_RESERVED_PARAMETERS == null)
|| (_PORTLET_URL_REFRESH_URL_RESERVED_PARAMETERS.length == 0)) {
return false;
}
for (int i = 0; i < _PORTLET_URL_REFRESH_URL_RESERVED_PARAMETERS.length; i++) {
String reservedParameter = namespace.concat(_PORTLET_URL_REFRESH_URL_RESERVED_PARAMETERS[i]);
if (parameter.equals(reservedParameter)) {
return true;
}
}
return false;
}
private static final int _CURRENT_URL_PARAMETER_THRESHOLD = 32768;
private static final String[] _PORTLET_URL_REFRESH_URL_RESERVED_PARAMETERS =
PropsUtil.getArray(PropsKeys.PORTLET_URL_REFRESH_URL_RESERVED_PARAMETERS);
}
protected static void setHeaders(
HttpServletRequest request,
HttpServletResponse response,
String fileName,
String contentType) {
if (_log.isDebugEnabled()) {
_log.debug("Sending file of type " + contentType);
}
// LEP-2201
if (Validator.isNotNull(contentType)) {
response.setContentType(contentType);
}
response.setHeader(HttpHeaders.CACHE_CONTROL, HttpHeaders.CACHE_CONTROL_PUBLIC_VALUE);
response.setHeader(HttpHeaders.PRAGMA, HttpHeaders.PRAGMA_PUBLIC_VALUE);
if (Validator.isNotNull(fileName)) {
String contentDisposition = "attachment; filename=\"" + fileName + "\"";
// If necessary for non-ASCII characters, encode based on RFC 2184.
// However, not all browsers support RFC 2184. See LEP-3127.
boolean ascii = true;
for (int i = 0; i < fileName.length(); i++) {
if (!Validator.isAscii(fileName.charAt(i))) {
ascii = false;
break;
}
}
try {
if (!ascii) {
String encodedFileName = HttpUtil.encodeURL(fileName, true);
if (BrowserSnifferUtil.isIe(request)) {
contentDisposition = "attachment; filename=\"" + encodedFileName + "\"";
} else {
contentDisposition = "attachment; filename*=UTF-8''" + encodedFileName;
}
}
} catch (Exception e) {
if (_log.isWarnEnabled()) {
_log.warn(e);
}
}
String extension = GetterUtil.getString(FileUtil.getExtension(fileName)).toLowerCase();
String[] mimeTypesContentDispositionInline = null;
try {
mimeTypesContentDispositionInline =
PropsUtil.getArray("mime.types.content.disposition.inline");
} catch (Exception e) {
mimeTypesContentDispositionInline = new String[0];
}
if (ArrayUtil.contains(mimeTypesContentDispositionInline, extension)) {
contentDisposition = StringUtil.replace(contentDisposition, "attachment; ", "inline; ");
}
response.setHeader(HttpHeaders.CONTENT_DISPOSITION, contentDisposition);
}
}
/** @author Mika Koivisto */
@DoPrivileged
public class DLProcessorRegistryImpl implements DLProcessorRegistry {
public void afterPropertiesSet() throws Exception {
ClassLoader classLoader = ClassLoaderUtil.getPortalClassLoader();
for (String dlProcessorClassName : _DL_FILE_ENTRY_PROCESSORS) {
DLProcessor dlProcessor =
(DLProcessor) InstanceFactory.newInstance(classLoader, dlProcessorClassName);
dlProcessor.afterPropertiesSet();
register(dlProcessor);
}
}
@Override
public void cleanUp(FileEntry fileEntry) {
if (!DLProcessorThreadLocal.isEnabled()) {
return;
}
Iterable<String> dlProcessorTypes = _dlProcessorServiceTrackerMap.keySet();
for (String dlProcessorType : dlProcessorTypes) {
DLProcessor dlProcessor = _dlProcessorServiceTrackerMap.getService(dlProcessorType);
if (dlProcessor.isSupported(fileEntry.getMimeType())) {
dlProcessor.cleanUp(fileEntry);
}
}
}
@Override
public void cleanUp(FileVersion fileVersion) {
if (!DLProcessorThreadLocal.isEnabled()) {
return;
}
Iterable<String> dlProcessorTypes = _dlProcessorServiceTrackerMap.keySet();
for (String dlProcessorType : dlProcessorTypes) {
DLProcessor dlProcessor = _dlProcessorServiceTrackerMap.getService(dlProcessorType);
if (dlProcessor.isSupported(fileVersion)) {
dlProcessor.cleanUp(fileVersion);
}
}
}
@Override
public void exportGeneratedFiles(
PortletDataContext portletDataContext, FileEntry fileEntry, Element fileEntryElement)
throws Exception {
if ((fileEntry == null) || (fileEntry.getSize() == 0)) {
return;
}
FileVersion latestFileVersion = _getLatestFileVersion(fileEntry, true);
if (latestFileVersion == null) {
return;
}
Iterable<String> dlProcessorTypes = _dlProcessorServiceTrackerMap.keySet();
for (String dlProcessorType : dlProcessorTypes) {
DLProcessor dlProcessor = _dlProcessorServiceTrackerMap.getService(dlProcessorType);
if (dlProcessor.isSupported(latestFileVersion)) {
dlProcessor.exportGeneratedFiles(portletDataContext, fileEntry, fileEntryElement);
}
}
}
@Override
public DLProcessor getDLProcessor(String dlProcessorType) {
return _dlProcessorServiceTrackerMap.getService(dlProcessorType);
}
@Override
public void importGeneratedFiles(
PortletDataContext portletDataContext,
FileEntry fileEntry,
FileEntry importedFileEntry,
Element fileEntryElement)
throws Exception {
if ((importedFileEntry == null) || (importedFileEntry.getSize() == 0)) {
return;
}
FileVersion fileVersion = importedFileEntry.getFileVersion();
if (fileVersion == null) {
return;
}
Iterable<String> dlProcessorTypes = _dlProcessorServiceTrackerMap.keySet();
for (String dlProcessorType : dlProcessorTypes) {
DLProcessor dlProcessor = _dlProcessorServiceTrackerMap.getService(dlProcessorType);
if (dlProcessor.isSupported(fileVersion)) {
dlProcessor.importGeneratedFiles(
portletDataContext, fileEntry, importedFileEntry, fileEntryElement);
}
}
}
@Override
public boolean isPreviewableSize(FileVersion fileVersion) {
long fileEntryPreviewableProcessorMaxSize =
PropsValues.DL_FILE_ENTRY_PREVIEWABLE_PROCESSOR_MAX_SIZE;
try {
fileEntryPreviewableProcessorMaxSize =
PrefsPropsUtil.getLong(PropsKeys.DL_FILE_ENTRY_PREVIEWABLE_PROCESSOR_MAX_SIZE);
} catch (Exception e) {
_log.error(e, e);
}
if (fileEntryPreviewableProcessorMaxSize == 0) {
return false;
}
if ((fileEntryPreviewableProcessorMaxSize > 0)
&& (fileVersion.getSize() > fileEntryPreviewableProcessorMaxSize)) {
return false;
}
return true;
}
@Override
public void register(DLProcessor dlProcessor) {
Registry registry = RegistryUtil.getRegistry();
ServiceRegistration<DLProcessor> previousServiceRegistration =
_serviceRegistrations.remove(dlProcessor.getType());
if (previousServiceRegistration != null) {
previousServiceRegistration.unregister();
}
ServiceRegistration<DLProcessor> serviceRegistration =
registry.registerService(DLProcessor.class, dlProcessor);
_serviceRegistrations.put(dlProcessor.getType(), serviceRegistration);
}
@Override
public void trigger(FileEntry fileEntry, FileVersion fileVersion) {
trigger(fileEntry, fileVersion, false);
}
@Override
public void trigger(FileEntry fileEntry, FileVersion fileVersion, boolean trusted) {
if (!DLProcessorThreadLocal.isEnabled()) {
return;
}
if ((fileEntry == null) || (fileEntry.getSize() == 0)) {
return;
}
FileVersion latestFileVersion = _getLatestFileVersion(fileEntry, trusted);
if (latestFileVersion == null) {
return;
}
Iterable<String> dlProcessorTypes = _dlProcessorServiceTrackerMap.keySet();
for (String dlProcessorType : dlProcessorTypes) {
DLProcessor dlProcessor = _dlProcessorServiceTrackerMap.getService(dlProcessorType);
if (dlProcessor.isSupported(latestFileVersion)) {
dlProcessor.trigger(fileVersion, latestFileVersion);
}
}
}
@Override
public void unregister(DLProcessor dlProcessor) {
ServiceRegistration<DLProcessor> serviceRegistration =
_serviceRegistrations.remove(dlProcessor.getType());
serviceRegistration.unregister();
}
private FileVersion _getLatestFileVersion(FileEntry fileEntry, boolean trusted) {
try {
return fileEntry.getLatestFileVersion(trusted);
} catch (Exception e) {
_log.error(e, e);
return null;
}
}
private static final String[] _DL_FILE_ENTRY_PROCESSORS =
PropsUtil.getArray(PropsKeys.DL_FILE_ENTRY_PROCESSORS);
private static final Log _log = LogFactoryUtil.getLog(DLProcessorRegistryImpl.class);
private final ServiceTrackerMap<String, DLProcessor> _dlProcessorServiceTrackerMap =
ServiceTrackerCollections.openSingleValueMap(
DLProcessor.class,
null,
new ServiceReferenceMapper<String, DLProcessor>() {
@Override
public void map(
ServiceReference<DLProcessor> serviceReference, Emitter<String> emitter) {
Registry registry = RegistryUtil.getRegistry();
DLProcessor dlProcessor = registry.getService(serviceReference);
try {
emitter.emit(dlProcessor.getType());
} finally {
registry.ungetService(serviceReference);
}
}
});
private final StringServiceRegistrationMap<DLProcessor> _serviceRegistrations =
new StringServiceRegistrationMapImpl<>();
}
