public String getDDLRecordSetDisplayStyle() {
if (_ddlRecordDisplayStyle == null) {
PortalPreferences portalPreferences =
PortletPreferencesFactoryUtil.getPortalPreferences(_ddlRequestHelper.getRenderRequest());
_ddlRecordDisplayStyle =
ParamUtil.getString(_ddlRequestHelper.getRenderRequest(), "displayStyle");
if (Validator.isNull(_ddlRecordDisplayStyle)) {
_ddlRecordDisplayStyle =
portalPreferences.getValue(
DDLPortletKeys.DYNAMIC_DATA_LISTS,
"display-style",
_ddlWebConfiguration.defaultDisplayView());
} else if (ArrayUtil.contains(getDDLRecordSetDisplayViews(), _ddlRecordDisplayStyle)) {
portalPreferences.setValue(
DDLPortletKeys.DYNAMIC_DATA_LISTS, "display-style", _ddlRecordDisplayStyle);
}
if (!ArrayUtil.contains(getDDLRecordSetDisplayViews(), _ddlRecordDisplayStyle)) {
_ddlRecordDisplayStyle = getDDLRecordSetDisplayViews()[0];
}
}
return _ddlRecordDisplayStyle;
}
private static List<String> _getDependencies(String bundleId, List<String> dependencies) {
if (!ArrayUtil.contains(PropsValues.JAVASCRIPT_BUNDLE_IDS, bundleId)) {
return dependencies;
}
String[] bundleDependencies =
PropsUtil.getArray(PropsKeys.JAVASCRIPT_BUNDLE_DEPENDENCIES, new Filter(bundleId));
for (String bundleDependency : bundleDependencies) {
String[] bundleDependencyDependencies =
PropsUtil.getArray(
PropsKeys.JAVASCRIPT_BUNDLE_DEPENDENCIES, new Filter(bundleDependency));
if (!ArrayUtil.contains(bundleDependencyDependencies, bundleId)) {
_getDependencies(bundleDependency, dependencies);
}
dependencies.add(bundleDependency);
}
dependencies.add(bundleId);
return dependencies;
}
protected String getDisplayStyle(HttpServletRequest request, String[] displayViews) {
PortalPreferences portalPreferences =
PortletPreferencesFactoryUtil.getPortalPreferences(request);
String displayStyle = ParamUtil.getString(request, "displayStyle");
if (Validator.isNull(displayStyle)) {
JournalWebConfiguration journalWebConfiguration =
(JournalWebConfiguration) _request.getAttribute(JournalWebConfiguration.class.getName());
displayStyle =
portalPreferences.getValue(
JournalPortletKeys.JOURNAL,
"display-style",
journalWebConfiguration.defaultDisplayView());
} else {
if (ArrayUtil.contains(displayViews, displayStyle)) {
portalPreferences.setValue(JournalPortletKeys.JOURNAL, "display-style", displayStyle);
request.setAttribute(WebKeys.SINGLE_PAGE_APPLICATION_CLEAR_CACHE, Boolean.TRUE);
}
}
if (!ArrayUtil.contains(displayViews, displayStyle)) {
displayStyle = displayViews[0];
}
return displayStyle;
}
protected Map<String, List<String>> getFolderNameFileEntryNamesMap(ZipReader zipReader) {
Map<String, List<String>> folderNameFileEntryNamesMap = new TreeMap<String, List<String>>();
for (String zipEntry : zipReader.getEntries()) {
String extension = FileUtil.getExtension(zipEntry);
if (!ArrayUtil.contains(
PortletPropsValues.MARKDOWN_IMPORTER_ARTICLE_EXTENSIONS,
StringPool.PERIOD.concat(extension))
|| zipEntry.equals(PortletPropsValues.MARKDOWN_IMPORTER_ARTICLE_HOME)) {
continue;
}
String folderName = zipEntry.substring(0, zipEntry.lastIndexOf(StringPool.SLASH));
List<String> fileEntryNames = folderNameFileEntryNamesMap.get(folderName);
if (fileEntryNames == null) {
fileEntryNames = new ArrayList<String>();
}
fileEntryNames.add(zipEntry);
folderNameFileEntryNamesMap.put(folderName, fileEntryNames);
}
return folderNameFileEntryNamesMap;
}
public String[] getAllAssetTagNames() throws Exception {
if (_allAssetTagNames != null) {
return _allAssetTagNames;
}
_allAssetTagNames = new String[0];
String assetTagName = ParamUtil.getString(_request, "tag");
String selectionStyle = getSelectionStyle();
if (selectionStyle.equals("dynamic")) {
_allAssetTagNames = AssetPublisherUtil.getAssetTagNames(_portletPreferences);
}
if (Validator.isNotNull(assetTagName) && !ArrayUtil.contains(_allAssetTagNames, assetTagName)) {
_allAssetTagNames = ArrayUtil.append(_allAssetTagNames, assetTagName);
}
if (isMergeURLTags()) {
_allAssetTagNames = ArrayUtil.append(_allAssetTagNames, getCompilerTagNames());
}
_allAssetTagNames = ArrayUtil.distinct(_allAssetTagNames, new StringComparator());
return _allAssetTagNames;
}
protected void validateDDMFormFieldIndexType(DDMFormField ddmFormField)
throws DDMFormValidationException {
if (!ArrayUtil.contains(_ddmFormFieldIndexTypes, ddmFormField.getIndexType())) {
throw new MustSetValidIndexType(ddmFormField.getName());
}
}
protected void addChildCalendarBookings(
CalendarBooking calendarBooking, long[] childCalendarIds, ServiceContext serviceContext)
throws PortalException, SystemException {
if (!calendarBooking.isMasterBooking()) {
return;
}
List<CalendarBooking> childCalendarBookings =
calendarBookingPersistence.findByParentCalendarBookingId(
calendarBooking.getCalendarBookingId());
for (CalendarBooking childCalendarBooking : childCalendarBookings) {
if (childCalendarBooking.isMasterBooking()
|| ArrayUtil.contains(childCalendarIds, childCalendarBooking.getCalendarId())) {
continue;
}
deleteCalendarBooking(childCalendarBooking.getCalendarBookingId());
}
for (long calendarId : childCalendarIds) {
int count =
calendarBookingPersistence.countByC_P(calendarId, calendarBooking.getCalendarBookingId());
if (count > 0) {
continue;
}
CalendarBooking childCalendarBooking =
addCalendarBooking(
calendarBooking.getUserId(),
calendarId,
new long[0],
calendarBooking.getCalendarBookingId(),
calendarBooking.getTitleMap(),
calendarBooking.getDescriptionMap(),
calendarBooking.getLocation(),
calendarBooking.getStartDate(),
calendarBooking.getEndDate(),
calendarBooking.getAllDay(),
calendarBooking.getRecurrence(),
calendarBooking.getFirstReminder(),
calendarBooking.getFirstReminderType(),
calendarBooking.getSecondReminder(),
calendarBooking.getSecondReminderType(),
serviceContext);
try {
NotificationType notificationType =
NotificationType.parse(PortletPropsValues.CALENDAR_NOTIFICATION_DEFAULT_TYPE);
NotificationUtil.notifyCalendarBookingInvites(childCalendarBooking, notificationType);
} catch (Exception e) {
}
}
}
protected void validateDDMFormFieldIndexType(DDMFormField ddmFormField)
throws DDMFormValidationException {
if (!ArrayUtil.contains(_ddmFormFieldIndexTypes, ddmFormField.getIndexType())) {
throw new DDMFormValidationException(
"Invalid index type set for field " + ddmFormField.getName());
}
}
/** @deprecated As of 6.2.0, replaced by {@link #normalize(String, Pattern)} */
@Deprecated
@Override
public String normalize(String friendlyURL, char[] replaceChars) {
if (Validator.isNull(friendlyURL)) {
return friendlyURL;
}
friendlyURL = GetterUtil.getString(friendlyURL);
friendlyURL = StringUtil.toLowerCase(friendlyURL);
friendlyURL = Normalizer.normalizeToAscii(friendlyURL);
StringBuilder sb = null;
int index = 0;
for (int i = 0; i < friendlyURL.length(); i++) {
char c = friendlyURL.charAt(i);
if ((Arrays.binarySearch(_REPLACE_CHARS, c) >= 0)
|| ((replaceChars != null) && ArrayUtil.contains(replaceChars, c))) {
if (sb == null) {
sb = new StringBuilder();
}
if (i > index) {
sb.append(friendlyURL.substring(index, i));
}
sb.append(CharPool.DASH);
index = i + 1;
}
}
if (sb != null) {
if (index < friendlyURL.length()) {
sb.append(friendlyURL.substring(index));
}
friendlyURL = sb.toString();
}
while (friendlyURL.contains(StringPool.DOUBLE_DASH)) {
friendlyURL = StringUtil.replace(friendlyURL, StringPool.DOUBLE_DASH, StringPool.DASH);
}
/*if (friendlyURL.startsWith(StringPool.DASH)) {
friendlyURL = friendlyURL.substring(1);
}
if (friendlyURL.endsWith(StringPool.DASH)) {
friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
}*/
return friendlyURL;
}
@Test
public void testAddFileEntryType() throws Exception {
ServiceContext serviceContext = new ServiceContext();
byte[] testFileBytes = FileUtil.getBytes(getClass(), _TEST_DDM_STRUCTURE);
serviceContext.setAttribute("xsd", new String(testFileBytes));
User user = TestPropsValues.getUser();
serviceContext.setLanguageId(LocaleUtil.toLanguageId(user.getLocale()));
DLFileEntryType dlFileEntryType =
DLFileEntryTypeLocalServiceUtil.addFileEntryType(
TestPropsValues.getUserId(),
_group.getGroupId(),
"Test Structure",
StringPool.BLANK,
new long[0],
serviceContext);
List<DDMStructure> ddmStructures = dlFileEntryType.getDDMStructures();
Assert.assertEquals(1, ddmStructures.size());
DDMStructure ddmStructure = ddmStructures.get(0);
Locale[] availableLocales = LocaleUtil.fromLanguageIds(ddmStructure.getAvailableLanguageIds());
boolean hasDefaultLocale = ArrayUtil.contains(availableLocales, LocaleUtil.getSiteDefault());
Assert.assertTrue(hasDefaultLocale);
boolean hasHungarianLocale = ArrayUtil.contains(availableLocales, LocaleUtil.HUNGARY);
Assert.assertTrue(hasHungarianLocale);
boolean hasUserLocale = ArrayUtil.contains(availableLocales, user.getLocale());
Assert.assertTrue(hasUserLocale);
DLFileEntryTypeLocalServiceUtil.deleteDLFileEntryType(dlFileEntryType);
}
public static String checkOrderByCol(String orderByCol) {
if (ArrayUtil.contains(ORDER_BY_COLUMNS, orderByCol)
|| ((orderByCol != null)
&& orderByCol.startsWith(DDMStructureManager.STRUCTURE_INDEXER_FIELD_PREFIX))) {
return orderByCol;
}
return ORDER_BY_COLUMNS[2];
}
protected void updateLayoutSetPrototype(long groupId, boolean privateLayout)
throws PortalException {
// Layout
LayoutSet layoutSet = LayoutSetLocalServiceUtil.getLayoutSet(groupId, privateLayout);
LayoutSetPrototype layoutSetPrototype =
LayoutSetPrototypeLocalServiceUtil.getLayoutSetPrototype(
layoutSet.getLayoutSetPrototypeId());
Group layoutSetPrototypeGroup = layoutSetPrototype.getGroup();
List<Layout> layoutSetPrototypeLayouts =
LayoutLocalServiceUtil.getLayouts(layoutSetPrototypeGroup.getGroupId(), true);
String[] layoutSetPrototypeLayoutUuids = new String[layoutSetPrototypeLayouts.size()];
for (int i = 0; i < layoutSetPrototypeLayouts.size(); i++) {
Layout layout = layoutSetPrototypeLayouts.get(i);
layoutSetPrototypeLayoutUuids[i] = layout.getUuid();
}
List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(groupId, privateLayout);
for (Layout layout : layouts) {
if (ArrayUtil.contains(
layoutSetPrototypeLayoutUuids, layout.getSourcePrototypeLayoutUuid())) {
layout.setLayoutPrototypeUuid(StringPool.BLANK);
layout.setLayoutPrototypeLinkEnabled(false);
layout.setSourcePrototypeLayoutUuid(StringPool.BLANK);
LayoutLocalServiceUtil.updateLayout(layout);
}
}
// Layout set
UnicodeProperties settingsProperties = layoutSet.getSettingsProperties();
settingsProperties.remove("last-merge-time");
layoutSet.setSettingsProperties(settingsProperties);
layoutSet.setLayoutSetPrototypeUuid(StringPool.BLANK);
layoutSet.setLayoutSetPrototypeLinkEnabled(false);
LayoutSetLocalServiceUtil.updateLayoutSet(layoutSet);
LayoutSetLocalServiceUtil.updateLookAndFeel(
layoutSet.getGroupId(), null, null, StringPool.BLANK, false);
}
public String getPaginationType() {
if (_paginationType == null) {
_paginationType =
GetterUtil.getString(_portletPreferences.getValue("paginationType", "none"));
if (!ArrayUtil.contains(PAGINATION_TYPES, _paginationType)) {
_paginationType = PAGINATION_TYPE_NONE;
}
}
return _paginationType;
}
private void _addCompanyId(long companyId) {
if (ArrayUtil.contains(_companyIds, companyId)) {
return;
}
long[] companyIds = new long[_companyIds.length + 1];
System.arraycopy(_companyIds, 0, companyIds, 0, _companyIds.length);
companyIds[_companyIds.length] = companyId;
_companyIds = companyIds;
}
protected void validateBlockElement(
String fileName,
Element commandElement,
String[] allowedBlockChildElementNames,
String[] allowedExecuteAttributeNames,
String[] allowedExecuteChildElementNames,
String[] allowedIfConditionElementNames) {
List<Element> elements = commandElement.elements();
if (elements.isEmpty()) {
throwValidationException(1001, fileName, commandElement, allowedBlockChildElementNames);
}
for (Element element : elements) {
String elementName = element.getName();
if (!ArrayUtil.contains(allowedBlockChildElementNames, elementName)) {
throwValidationException(1002, fileName, element, elementName);
}
if (elementName.equals("echo") || elementName.equals("fail")) {
validateSimpleElement(fileName, element, new String[] {"message"});
} else if (elementName.equals("execute")) {
validateExecuteElement(
fileName, element, allowedExecuteAttributeNames, ".+", allowedExecuteChildElementNames);
} else if (elementName.equals("if")) {
validateIfElement(
fileName,
element,
allowedBlockChildElementNames,
allowedExecuteAttributeNames,
allowedExecuteChildElementNames,
allowedIfConditionElementNames);
} else if (elementName.equals("var")) {
validateVarElement(fileName, element);
} else if (elementName.equals("while")) {
validateWhileElement(
fileName,
element,
allowedBlockChildElementNames,
allowedExecuteAttributeNames,
allowedExecuteChildElementNames,
allowedIfConditionElementNames);
} else {
throwValidationException(1002, fileName, element, elementName);
}
}
}
public static String getDDLRecordSetDisplayStyle(
PortletRequest portletRequest, String[] displayViews) {
PortalPreferences portalPreferences =
PortletPreferencesFactoryUtil.getPortalPreferences(portletRequest);
String displayStyle = ParamUtil.getString(portletRequest, "displayStyle");
if (Validator.isNull(displayStyle)) {
displayStyle =
portalPreferences.getValue(
DDLPortletKeys.DYNAMIC_DATA_LISTS,
"display-style",
DDLWebConfigurationValues.DEFAULT_DISPLAY_VIEW);
} else if (ArrayUtil.contains(displayViews, displayStyle)) {
portalPreferences.setValue(DDLPortletKeys.DYNAMIC_DATA_LISTS, "display-style", displayStyle);
}
if (!ArrayUtil.contains(displayViews, displayStyle)) {
displayStyle = displayViews[0];
}
return displayStyle;
}
public String normalize(String fileName, char[] replaceChars) {
if (Validator.isNull(fileName)) {
return fileName;
}
fileName = GetterUtil.getString(fileName);
fileName = fileName.toLowerCase();
fileName = Normalizer.normalizeToAscii(fileName);
StringBuilder sb = null;
int index = 0;
for (int i = 0; i < fileName.length(); i++) {
char c = fileName.charAt(i);
if ((Arrays.binarySearch(_REPLACE_CHARS, c) >= 0)
|| ((replaceChars != null) && ArrayUtil.contains(replaceChars, c))) {
if (sb == null) {
sb = new StringBuilder();
}
if (i > index) {
sb.append(fileName.substring(index, i));
}
sb.append(CharPool.DASH);
// sb.append(CharPool.UNDERLINE);
index = i + 1;
}
}
if (sb != null) {
if (index < fileName.length()) {
sb.append(fileName.substring(index));
}
fileName = sb.toString();
}
while (fileName.indexOf(StringPool.DOUBLE_DASH) >= 0) {
fileName = StringUtil.replace(fileName, StringPool.DOUBLE_DASH, StringPool.DASH);
}
return fileName;
}
private int _countMatchedElements(String[] parameterNames, MethodParameter[] methodParameters) {
int matched = 0;
for (MethodParameter methodParameter : methodParameters) {
String methodParameterName = methodParameter.getName();
methodParameterName = CamelCaseUtil.normalizeCamelCase(methodParameterName);
if (ArrayUtil.contains(parameterNames, methodParameterName)) {
matched++;
}
}
return matched;
}
public String[] getEntryColumns() throws PortalException, SystemException {
String[] entryColumns = _dlPortletInstanceSettings.getEntryColumns();
String portletId = _portletDisplay.getId();
if (!_dlActionsDisplayContext.isShowActions()) {
entryColumns = ArrayUtil.remove(entryColumns, "action");
} else if (!portletId.equals(PortletKeys.DOCUMENT_LIBRARY)
&& !portletId.equals(PortletKeys.DOCUMENT_LIBRARY_ADMIN)
&& !ArrayUtil.contains(entryColumns, "action")) {
entryColumns = ArrayUtil.append(entryColumns, "action");
}
return entryColumns;
}
@Override
public int countScoredFieldNames(Query query, String[] filedNames) {
int count = 0;
for (String fieldName : filedNames) {
WeightedTerm[] weightedTerms = QueryTermExtractor.getTerms(query, false, fieldName);
if ((weightedTerms.length > 0)
&& !ArrayUtil.contains(Field.UNSCORED_FIELD_NAMES, fieldName)) {
count++;
}
}
return count;
}
protected void exportLayout(
PortletDataContext portletDataContext, long[] layoutIds, Layout layout) throws Exception {
if (!ArrayUtil.contains(layoutIds, layout.getLayoutId())) {
Element layoutElement = portletDataContext.getExportDataElement(layout);
layoutElement.addAttribute(Constants.ACTION, Constants.SKIP);
return;
}
if (!prepareLayoutStagingHandler(portletDataContext, layout)) {
return;
}
StagedModelDataHandlerUtil.exportStagedModel(portletDataContext, layout);
}
/**
* @deprecated As of 1.5.0, replaced by {@link #sendFile(String, PortletRequest, PortletResponse)}
*/
@Deprecated
public void sendFile(PortletRequest portletRequest, PortletResponse portletResponse)
throws IOException {
String targetExtension = ParamUtil.getString(portletRequest, "targetExtension");
PortletPreferences portletPreferences = portletRequest.getPreferences();
String[] allowedExtensions = StringUtil.split(portletPreferences.getValue("extensions", null));
if (Validator.isNull(targetExtension)
|| !ArrayUtil.contains(allowedExtensions, targetExtension)) {
return;
}
sendFile(targetExtension, portletRequest, portletResponse);
}
protected String[] appendPortletIds(
String[] portletIds, String[] newPortletIds, String portletsMergeMode) {
for (String portletId : newPortletIds) {
if (ArrayUtil.contains(portletIds, portletId)) {
continue;
}
if (portletsMergeMode.equals(PortletDataHandlerKeys.PORTLETS_MERGE_MODE_ADD_TO_BOTTOM)) {
portletIds = ArrayUtil.append(portletIds, portletId);
} else {
portletIds = ArrayUtil.append(new String[] {portletId}, portletIds);
}
}
return portletIds;
}
@Override
protected void validateExport(PortletDataContext portletDataContext, DDLRecord record)
throws PortletDataException {
int status = WorkflowConstants.STATUS_ANY;
try {
status = record.getStatus();
} catch (Exception e) {
throw new PortletDataException(e);
}
if (!ArrayUtil.contains(getExportableStatuses(), status)) {
PortletDataException pde = new PortletDataException(PortletDataException.STATUS_UNAVAILABLE);
pde.setStagedModel(record);
throw pde;
}
}
@Override
protected Metadata extractMetadata(String extension, String mimeType, InputStream inputStream) {
Metadata metadata = super.extractMetadata(extension, mimeType, inputStream);
boolean forkProcess = false;
if (PropsValues.TEXT_EXTRACTION_FORK_PROCESS_ENABLED) {
if (ArrayUtil.contains(PropsValues.TEXT_EXTRACTION_FORK_PROCESS_MIME_TYPES, mimeType)) {
forkProcess = true;
}
}
if (forkProcess) {
File file = FileUtil.createTempFile();
try {
FileUtil.write(file, inputStream);
ExtractMetadataProcessCallable extractMetadataProcessCallable =
new ExtractMetadataProcessCallable(file, metadata, _parser);
Future<Metadata> future =
ProcessExecutor.execute(
ClassPathUtil.getPortalProcessConfig(), extractMetadataProcessCallable);
return future.get();
} catch (Exception e) {
throw new SystemException(e);
} finally {
file.delete();
}
}
try {
return extractMetadata(inputStream, metadata, _parser);
} catch (IOException ioe) {
throw new SystemException(ioe);
}
}
protected UnicodeProperties addLDAPServer(long companyId, UnicodeProperties properties)
throws Exception {
String defaultPostfix = LDAPSettingsUtil.getPropertyPostfix(0);
String[] defaultKeys = new String[_KEYS.length];
for (int i = 0; i < _KEYS.length; i++) {
defaultKeys[i] = _KEYS[i] + defaultPostfix;
}
long ldapServerId = CounterLocalServiceUtil.increment();
String postfix = LDAPSettingsUtil.getPropertyPostfix(ldapServerId);
String[] keys = properties.keySet().toArray(new String[0]);
for (String key : keys) {
if (ArrayUtil.contains(defaultKeys, key)) {
String value = properties.remove(key);
if (key.equals(PropsKeys.LDAP_SECURITY_CREDENTIALS + defaultPostfix)
&& value.equals(Portal.TEMP_OBFUSCATION_VALUE)) {
value = PrefsPropsUtil.getString(PropsKeys.LDAP_SECURITY_CREDENTIALS);
}
properties.setProperty(key.replace(defaultPostfix, postfix), value);
}
}
PortletPreferences preferences = PrefsPropsUtil.getPreferences(companyId);
String ldapServerIds = preferences.getValue("ldap.server.ids", StringPool.BLANK);
ldapServerIds = StringUtil.add(ldapServerIds, String.valueOf(ldapServerId));
properties.setProperty("ldap.server.ids", ldapServerIds);
return properties;
}
protected SkinnyJournalArticle getSkinnyJournalArticle(
JournalArticle journalArticle, String locale) throws Exception {
SkinnyJournalArticle skinnyJournalArticle = new SkinnyJournalArticle();
String content = null;
if (ArrayUtil.contains(journalArticle.getAvailableLocales(), locale)) {
content = journalArticle.getContentByLocale(locale);
} else {
content = journalArticle.getContent();
}
Document document = SAXReaderUtil.read(content);
Element rootElement = document.getRootElement();
populateSkinnyJournalArticle(skinnyJournalArticle, rootElement);
return skinnyJournalArticle;
}
@Override
protected void validateExport(PortletDataContext portletDataContext, FileEntry fileEntry)
throws PortletDataException {
if ((fileEntry.getGroupId() != portletDataContext.getGroupId())
&& (fileEntry.getGroupId() != portletDataContext.getScopeGroupId())) {
PortletDataException pde = new PortletDataException(PortletDataException.INVALID_GROUP);
pde.setStagedModel(fileEntry);
throw pde;
}
try {
FileVersion fileVersion = fileEntry.getFileVersion();
if (!portletDataContext.isInitialPublication()
&& !ArrayUtil.contains(getExportableStatuses(), fileVersion.getStatus())) {
throw new PortletDataException(PortletDataException.STATUS_UNAVAILABLE);
}
} catch (PortletDataException pde) {
throw pde;
} catch (Exception e) {
if (_log.isDebugEnabled()) {
_log.debug(e, e);
} else if (_log.isWarnEnabled()) {
_log.warn("Unable to check workflow status for file entry " + fileEntry.getFileEntryId());
}
}
if (fileEntry.isInTrash() || fileEntry.isInTrashContainer()) {
PortletDataException pde = new PortletDataException(PortletDataException.STATUS_IN_TRASH);
pde.setStagedModel(fileEntry);
throw pde;
}
}
public boolean isShowImageEditorAction() throws PortalException {
if (_isShowImageEditorAction != null) {
return _isShowImageEditorAction;
}
if (!isShowActions()) {
_isShowImageEditorAction = false;
} else if (!DLFileEntryPermission.contains(
_themeDisplay.getPermissionChecker(), _fileEntry, ActionKeys.UPDATE)
|| (_fileEntry.isCheckedOut() && !_fileEntry.hasLock())) {
_isShowImageEditorAction = false;
} else if (!ArrayUtil.contains(
PropsValues.DL_FILE_ENTRY_PREVIEW_IMAGE_MIME_TYPES, _fileEntry.getMimeType())) {
_isShowImageEditorAction = false;
} else {
_isShowImageEditorAction = true;
}
return _isShowImageEditorAction;
}
public long[] getAllAssetCategoryIds() throws Exception {
if (_allAssetCategoryIds != null) {
return _allAssetCategoryIds;
}
_allAssetCategoryIds = new long[0];
long assetCategoryId = ParamUtil.getLong(_request, "categoryId");
String selectionStyle = getSelectionStyle();
if (selectionStyle.equals("dynamic")) {
_allAssetCategoryIds = AssetPublisherUtil.getAssetCategoryIds(_portletPreferences);
}
if ((assetCategoryId > 0) && !ArrayUtil.contains(_allAssetCategoryIds, assetCategoryId)) {
_allAssetCategoryIds = ArrayUtil.append(_allAssetCategoryIds, assetCategoryId);
}
return _allAssetCategoryIds;
}
