/* * File : $Source: /alkacon/cvs/alkacon/com.alkacon.opencms.documentcenter/src/com/alkacon/opencms/documentcenter/CmsDocumentFactory.java,v $ * Date : $Date: 2010/12/30 12:52:48 $ * Version: $Revision: 1.5 $ * * This file is part of the Alkacon OpenCms Add-On Module Package * * Copyright (c) 2010 Alkacon Software GmbH (http://www.alkacon.com) * * The Alkacon OpenCms Add-On Module Package is free software: * you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The Alkacon OpenCms Add-On Module Package is distributed * in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with the Alkacon OpenCms Add-On Module Package. * If not, see http://www.gnu.org/licenses/. * * For further information about Alkacon Software GmbH, please see the * company website: http://www.alkacon.com. * * For further information about OpenCms, please see the * project website: http://www.opencms.org. */ package com.alkacon.opencms.v8.documentcenter; import org.opencms.file.CmsObject; import org.opencms.file.CmsProperty; import org.opencms.file.CmsPropertyDefinition; import org.opencms.file.CmsResource; import org.opencms.jsp.CmsJspActionElement; import org.opencms.main.CmsException; import org.opencms.main.OpenCms; import org.opencms.util.CmsFileUtil; import org.opencms.util.CmsStringUtil; import org.opencms.widgets.CmsCalendarWidget; import java.text.ParseException; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.Iterator; import java.util.List; import java.util.Locale; import java.util.Map; /** * Provides helper methods to create CmsDocument objects or sorted lists of CmsDocument objects from {@link org.opencms.file.CmsResource} objects.<p> * * @author Andreas Zahner * * @version $Revision: 1.5 $ * * @since 6.2.0 */ public final class CmsDocumentFactory { /** Property name of the document center start folder marker. */ public static final String PROPERTY_DOCCENTER_STARTFOLDER = "docs.startfolder"; /** * A comparator for the creation date of 2 documents ascending.<p> */ protected static final Comparator<CmsDocument> COMPARE_DATECREATED_ASC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = 0; if (d1.getDateCreated() > d2.getDateCreated()) { orderValue = 1; } else if (d1.getDateCreated() < d2.getDateCreated()) { orderValue = -1; } return orderBySecondCriteria(orderValue, d1, d2); } }; /** * A comparator for the creation date of 2 documents descending.<p> */ protected static final Comparator<CmsDocument> COMPARE_DATECREATED_DESC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = 0; if (d1.getDateCreated() > d2.getDateCreated()) { orderValue = -1; } else if (d1.getDateCreated() < d2.getDateCreated()) { orderValue = 1; } return orderBySecondCriteria(orderValue, d1, d2); } }; /** * A comparator for the last modified date of 2 documents ascending.<p> */ protected static final Comparator<CmsDocument> COMPARE_DATEMODIFIED_ASC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = 0; if (d1.getDateLastModified() > d2.getDateLastModified()) { orderValue = 1; } else if (d1.getDateLastModified() < d2.getDateLastModified()) { orderValue = -1; } return orderValue; } }; /** * A comparator for the last modified date of 2 documents descending.<p> */ protected static final Comparator<CmsDocument> COMPARE_DATEMODIFIED_DESC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = 0; if (d1.getDateLastModified() > d2.getDateLastModified()) { orderValue = -1; } else if (d1.getDateLastModified() < d2.getDateLastModified()) { orderValue = 1; } return orderValue; } }; /** * A comparator for the ID of 2 documents ascending ignoring case differences.<p> */ protected static final Comparator<CmsDocument> COMPARE_ID_ASC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = d1.getDocumentId().compareToIgnoreCase(d2.getDocumentId()); return orderBySecondCriteria(orderValue, d1, d2); } }; /** * A comparator for the ID of 2 documents descending ignoring case differences.<p> */ protected static final Comparator<CmsDocument> COMPARE_ID_DESC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = -(d1.getDocumentId().compareToIgnoreCase(d2.getDocumentId())); return orderBySecondCriteria(orderValue, d1, d2); } }; /** * A comparator for the postfix of 2 documents ascending ignoring case differences.<p> */ protected static final Comparator<CmsDocument> COMPARE_POSTFIX_ASC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = d1.getPostfixType().compareToIgnoreCase(d2.getPostfixType()); return orderBySecondCriteria(orderValue, d1, d2); } }; /** * A comparator for the postfix of 2 documents descending ignoring case differences.<p> */ protected static final Comparator<CmsDocument> COMPARE_POSTFIX_DESC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = -(d1.getPostfixType().compareToIgnoreCase(d2.getPostfixType())); return orderBySecondCriteria(orderValue, d1, d2); } }; /** * A comparator for the size of 2 documents ascending.<p> */ protected static final Comparator<CmsDocument> COMPARE_SIZE_ASC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = 0; if (d1.getSize() > d2.getSize()) { orderValue = 1; } else if (d1.getSize() < d2.getSize()) { orderValue = -1; } return orderBySecondCriteria(orderValue, d1, d2); } }; /** * A comparator for the size of 2 documents descending.<p> */ protected static final Comparator<CmsDocument> COMPARE_SIZE_DESC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = 0; if (d1.getSize() > d2.getSize()) { orderValue = -1; } else if (d1.getSize() < d2.getSize()) { orderValue = 1; } return orderBySecondCriteria(orderValue, d1, d2); } }; /** * A comparator for the sort order property value of 2 documents ascending.<p> */ protected static final Comparator<CmsDocument> COMPARE_SORTORDER_ASC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = 0; if (d1.getSortOrder() > d2.getSortOrder()) { orderValue = 1; } else if (d1.getSortOrder() < d2.getSortOrder()) { orderValue = -1; } return orderBySecondCriteria(orderValue, d1, d2); } }; /** * A comparator for the sort order property value of 2 documents descending.<p> */ protected static final Comparator<CmsDocument> COMPARE_SORTORDER_DESC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = 0; if (d1.getSortOrder() > d2.getSortOrder()) { orderValue = -1; } else if (d1.getSortOrder() < d2.getSortOrder()) { orderValue = 1; } return orderBySecondCriteria(orderValue, d1, d2); } }; /** * A comparator for the title of 2 documents ascending ignoring case differences.<p> */ protected static final Comparator<CmsDocument> COMPARE_TITLE_ASC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = d1.getTitle().compareToIgnoreCase(d2.getTitle()); return orderBySecondCriteria(orderValue, d1, d2); } }; /** * A comparator for the title of 2 documents descending ignoring case differences.<p> */ protected static final Comparator<CmsDocument> COMPARE_TITLE_DESC = new Comparator<CmsDocument>() { /** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(CmsDocument o1, CmsDocument o2) { CmsDocument d1 = getSortDocument(o1); CmsDocument d2 = getSortDocument(o2); int orderValue = -(d1.getTitle().compareToIgnoreCase(d2.getTitle())); return orderBySecondCriteria(orderValue, d1, d2); } }; /** Sort methods array for fast lookup. */ protected static final String[] SORT_METHODS = { CmsDocument.SORT_METHOD_ALPHABETICAL, CmsDocument.SORT_METHOD_BY_DATEMODIFIED, CmsDocument.SORT_METHOD_BY_SORTORDER, CmsDocument.SORT_METHOD_SIZE, CmsDocument.SORT_METHOD_TYPE, CmsDocument.SORT_METHOD_BY_DATECREATED, CmsDocument.SORT_METHOD_BY_ID}; /** Sort methods list for fast lookup. */ protected static final List<String> SORT_METHODS_LIST = Arrays.asList(SORT_METHODS); /** File names array which should be ignored as documents. */ protected static final String[] VFS_IGNORED_FILES = { "$", "index.", "news.html", "newdocuments.html", "newdocuments.jsp", "search.html"}; /** File names list which should be ignored as documents. */ protected static final List<String> VFS_IGNORED_FILES_LIST = Arrays.asList(VFS_IGNORED_FILES); /** * Hidden constructor, this is a utility class.<p> */ private CmsDocumentFactory() { // nothing to initialize } /** * Returns an initialized document object or a null document if the document should not be displayed in the list.<p> * * Only the resource name without path information is checked against the file name patterns to ignore.<p> * * @param cms the current users context * @param resource the resource acting as document * @param includeFolders flag to determine if folders are included or not * * @return an initialized document object or a null document */ public static CmsDocument createDocument(CmsObject cms, CmsResource resource, boolean includeFolders) { return createDocument(cms, resource, includeFolders, true, false); } /** * Returns an initialized document object or a null document if the document should not be displayed in the list.<p> * * @param cms the current users context * @param resource the resource acting as document * @param includeFolders flag to determine if folders are included or not * @param completePathForIgnored if true, the complete site path of the resource is checked for the ignored files patterns * * @return an initialized document object or a null document */ public static CmsDocument createDocument( CmsObject cms, CmsResource resource, boolean includeFolders, boolean completePathForIgnored) { return createDocument(cms, resource, includeFolders, true, completePathForIgnored); } /** * Returns an initialized document object or a null document if the document should not be displayed in the list.<p> * * The document visibility is only checked if the checkIgnored value is set to <code>true</code>.<p> * * @param cms the current users context * @param resource the resource acting as document * @param includeFolders flag to determine if folders are included or not * @param checkIgnored if true, the resource is checked if it should be ignored depending on the ignored files patterns * @param completePathForIgnored if true, the complete site path of the resource is checked for the ignored files patterns * * @return an initialized document object or a null document */ public static CmsDocument createDocument( CmsObject cms, CmsResource resource, boolean includeFolders, boolean checkIgnored, boolean completePathForIgnored) { // read all resource properties to get the needed information for the document Map<String, String> allProperties = null; try { allProperties = CmsProperty.toMap(cms.readPropertyObjects(resource, false)); } catch (Exception e) { // error reading properties allProperties = Collections.emptyMap(); } // check if the document should be added to the list String showDocumentValue = allProperties.get(CmsDocument.PROPERTY_SHOWDOCUMENT); if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(showDocumentValue)) { if (!Boolean.valueOf(showDocumentValue).booleanValue()) { return CmsDocument.getNullDocument(); } } else if (resource.isFolder() && !includeFolders) { return CmsDocument.getNullDocument(); } String path = cms.getSitePath(resource); // check if the document should not be shown if (checkIgnored && isIgnoredDocument(path, completePathForIgnored)) { return CmsDocument.getNullDocument(); } // set title and sort order from properties String title = null; if (resource.isFolder()) { // try to get localized title for folder String locTitle = CmsPropertyDefinition.PROPERTY_TITLE + "_" + cms.getRequestContext().getLocale().toString(); try { title = cms.readPropertyObject(resource, locTitle, false).getValue(); } catch (CmsException e) { // ignore, property might not be defined } } if (CmsStringUtil.isEmptyOrWhitespaceOnly(title)) { title = allProperties.get(CmsPropertyDefinition.PROPERTY_TITLE); } // check the presence of the title property if (CmsStringUtil.isEmptyOrWhitespaceOnly(title)) { title = resource.getName(); if (title.endsWith("/")) { title = title.substring(0, (title.length() - 1)); } } String sortOrder = allProperties.get(CmsDocument.PROPERTY_SORTORDER); // initialize the document CmsDocument cmsDocument = new CmsDocument(resource, path, cms.getRequestContext().getLocale(), title, sortOrder); // read the property for date created String dateCreated = null; try { dateCreated = cms.readPropertyObject(resource, "docs.datecreated", false).getValue(); } catch (CmsException e) { // ignore, property might not be defined } // if the property for date created is not empty, so set this property as date created to the resource if (CmsStringUtil.isNotEmpty(dateCreated)) { // get the long value from the date string long creationDate = 0; try { // try if the property docs.createddata is in german format creationDate = CmsCalendarWidget.getCalendarDate( org.opencms.workplace.Messages.get().getBundle(new Locale("de")), dateCreated, false); } catch (ParseException e1) { // try if the property docs.createddata is in english format try { creationDate = CmsCalendarWidget.getCalendarDate( org.opencms.workplace.Messages.get().getBundle(new Locale("en")), dateCreated, false); } catch (ParseException e2) { // invalid data format, do nothing else } } // set the property to the document if (creationDate != 0) { cmsDocument.setDateCreated(creationDate); } } // return the document return cmsDocument; } /** * Returns an initialized document including all language versions and attachments of the specified resource.<p> * * @param jsp the current users JSP context * @param resourceName the absolute path of the resource to get the document for * @return an initialized document including all language versions and attachments of the specified resource */ public static CmsDocument createDocumentWithVersions(CmsDocumentFrontend jsp, String resourceName) { // use special document list with flag "only versions" set to true List<CmsDocument> result = new CmsDocumentList( jsp.isUseTypes(), jsp.getDefaultType(), jsp.isUseAttachments(), jsp.isUseLanguages(), true, 2); CmsObject cms = jsp.getCmsObject(); try { // read the current resource CmsResource res = cms.readResource(resourceName); // add the document of the current resource to the list CmsDocument document = createDocument(cms, res, false, false, false); // check if there is a document with the given resource name if (document.isNullDocument()) { return document; } result.add(document); List<CmsResource> files = cms.getFilesInFolder(CmsResource.getFolderPath(resourceName)); if (files.contains(res)) { // remove the original file from the list of found files files.remove(res); } Iterator<CmsResource> i = files.iterator(); while (i.hasNext()) { CmsResource currRes = i.next(); // add the resource if it is not he same result.add(createDocument(cms, currRes, false, false, false)); } // close the list ((CmsDocumentList)result).closeList(); } catch (CmsException e) { // error getting documents } return result.get(0); } /** * Builds a list with all <code>{@link CmsDocument}</code> Objects inside a given folder sorted as specified by the sort method.<p> * * @param jsp the current users JSP context * @param folder the folder in as specified in the channel name * @param sortMethodProperty the sort method property of the folder of this resource * @return ArrayList with all documents of the specified folder */ public static List<CmsDocument> getDocumentsForFolder( CmsDocumentFrontend jsp, String folder, String sortMethodProperty) { sortMethodProperty = sortMethodProperty.trim(); CmsObject cms = jsp.getCmsObject(); // check if files and folders should be sorted together boolean sortIncludeFolders = false; if (sortMethodProperty.toLowerCase().indexOf(CmsDocument.VALUE_INCLUDE_FOLDERS) != -1) { sortMethodProperty = sortMethodProperty.substring(0, sortMethodProperty.lastIndexOf(":")); sortIncludeFolders = true; } try { // get all subfolders in the folder from the VFS List<CmsResource> subfolders = cms.getSubFolders(folder); // get all files in the folder from the VFS List<CmsResource> files = cms.getFilesInFolder(folder); List<CmsDocument> documentList = new ArrayList<CmsDocument>(files.size() + subfolders.size()); // sort files and folders together if (sortIncludeFolders) { files.addAll(subfolders); if (files.size() > 0) { documentList = getSortedDocuments(jsp, files, sortMethodProperty, true); } } else { // create separately sorted folder & files list if (subfolders.size() > 0) { documentList.addAll(getSortedDocuments(jsp, subfolders, sortMethodProperty, true)); } if (files.size() > 0) { documentList.addAll(getSortedDocuments(jsp, files, sortMethodProperty, false)); } } return documentList; } catch (Exception e) { // ignore } return new ArrayList<CmsDocument>(0); } /** * Returns the substituted link for the given resource in the document center.<p> * * @param jsp the current action element * @param resource the resource to get the link for * * @return the substituted link */ public static String getLink(CmsJspActionElement jsp, CmsResource resource) { return getLink(jsp, jsp.getRequestContext().removeSiteRoot(resource.getRootPath())); } /** * Returns the substituted link for the given resource path in the document center.<p> * * @param jsp the current action element * @param resourcePath the path to get the link for * * @return the substituted link */ public static String getLink(CmsJspActionElement jsp, String resourcePath) { String result = CmsFileUtil.removeTrailingSeparator(jsp.getRequestContext().getFolderUri()); String docCenterStartFolder = ""; docCenterStartFolder = (String)jsp.getRequest().getAttribute(CmsDocumentFrontend.ATTR_STARTPATH); if ((docCenterStartFolder != null) && resourcePath.startsWith(docCenterStartFolder)) { resourcePath = resourcePath.substring(docCenterStartFolder.length()); } result = OpenCms.getLinkManager().substituteLink(jsp.getCmsObject(), result + resourcePath); return result; } /** * Returns a sorted list of documents from a given list of resources.<p> * * @param jsp the current users JSP context * @param resources the resource list * @param sortMethod the sort method for the documents * @param includeFolders flag to determine if folders should be added to the document list * @return list with sorted documents */ public static List<CmsDocument> getSortedDocuments( CmsDocumentFrontend jsp, List<CmsResource> resources, String sortMethod, boolean includeFolders) { return getSortedDocuments(jsp, resources, sortMethod, includeFolders, false); } /** * Returns a sorted list of documents from a given list of resources.<p> * * @param jsp the current users JSP context * @param resources the resource list * @param sortMethod the sort method for the documents * @param includeFolders flag to determine if folders should be added to the document list * @param completePathForIgnored if true, the complete site path of the resource is checked for the ignored files patterns * @return list with sorted documents */ public static List<CmsDocument> getSortedDocuments( CmsDocumentFrontend jsp, List<CmsResource> resources, String sortMethod, boolean includeFolders, boolean completePathForIgnored) { if (sortMethod.toLowerCase().indexOf(CmsDocument.VALUE_INCLUDE_FOLDERS) != -1) { sortMethod = sortMethod.substring(0, sortMethod.lastIndexOf(":")); } // create for each file an instance of CmsDocument and add it to the list of all documents Iterator<CmsResource> allResources = resources.iterator(); List<CmsDocument> documentList = new CmsDocumentList( jsp.isUseTypes(), jsp.getDefaultType(), jsp.isUseAttachments(), jsp.isUseLanguages(), false, resources.size()); while (allResources.hasNext()) { CmsResource currentResource = allResources.next(); CmsDocument document = CmsDocumentFactory.createDocument( jsp.getCmsObject(), currentResource, includeFolders, completePathForIgnored); documentList.add(document); } // close the list ((CmsDocumentList)documentList).closeList(); // sort the documents if we found at least 2 documents if (documentList.size() > 1) { // extract the sort method parts to determine the sort method to use String sortDirection = ""; if (sortMethod.indexOf(":") != -1) { sortDirection = sortMethod.substring(sortMethod.indexOf(":") + 1); sortMethod = sortMethod.substring(0, sortMethod.indexOf(":")); } // determine the sort comparator to use if (CmsStringUtil.isEmpty(sortMethod)) { sortMethod = CmsDocument.SORT_METHOD_ALPHABETICAL; } Comparator<CmsDocument> comp = getSortComparator(sortMethod, sortDirection); // sort the documents Collections.sort(documentList, comp); } // clear objects to release memory allResources = null; return documentList; } /** * Returns the comparator to sort the document list with depending on the sort method and direction values.<p> * * @param sortMethod the sort method for the documents * @param sortDirection the dort direction (ascending or descending) for the documents * @return the comparator to sort the document list with */ protected static Comparator<CmsDocument> getSortComparator(String sortMethod, String sortDirection) { String key = sortMethod.trim().toLowerCase(); switch (SORT_METHODS_LIST.indexOf(key)) { case 0: // sort in alphabetical order if (sortDirection.equalsIgnoreCase(CmsDocument.SORT_DIRECTION_DESC)) { return COMPARE_TITLE_DESC; } else { return COMPARE_TITLE_ASC; } case 1: // sort by date (modified) if (sortDirection.equalsIgnoreCase(CmsDocument.SORT_DIRECTION_ASC)) { return COMPARE_DATEMODIFIED_ASC; } else { return COMPARE_DATEMODIFIED_DESC; } case 2: // sort by the value of the SortOrder property if (sortDirection.equalsIgnoreCase(CmsDocument.SORT_DIRECTION_ASC)) { return COMPARE_SORTORDER_ASC; } else { return COMPARE_SORTORDER_DESC; } case 3: // sort by file size if (sortDirection.equalsIgnoreCase(CmsDocument.SORT_DIRECTION_ASC)) { return COMPARE_SIZE_ASC; } else { return COMPARE_SIZE_DESC; } case 4: // sort by postfix type if (sortDirection.equalsIgnoreCase(CmsDocument.SORT_DIRECTION_DESC)) { return COMPARE_POSTFIX_DESC; } else { return COMPARE_POSTFIX_ASC; } case 5: // sort by date (created) if (sortDirection.equalsIgnoreCase(CmsDocument.SORT_DIRECTION_ASC)) { return COMPARE_DATECREATED_ASC; } else { return COMPARE_DATECREATED_DESC; } case 6: // sort by document ID if (sortDirection.equalsIgnoreCase(CmsDocument.SORT_DIRECTION_DESC)) { return COMPARE_ID_DESC; } else { return COMPARE_ID_ASC; } default: return COMPARE_TITLE_ASC; } } /** * Returns the document for the sort procedure matching the current frontend locale.<p> * * @param o the Object to be sorted * @return the document for the sort procedure matching the current frontend locale */ protected static CmsDocument getSortDocument(CmsDocument o) { return o.getDocumentForCurrentLocale(); } /** * Returns if the document should be ignored depending on its resource name.<p> * * @param resourcePath the site path of the document to check * @param completePathForIgnored if true, the complete site path of the resource is checked for the ignored files patterns * @return true if the document should be ignored depending on its resource name, otherwise false */ protected static boolean isIgnoredDocument(String resourcePath, boolean completePathForIgnored) { Iterator<String> i = VFS_IGNORED_FILES_LIST.iterator(); String resourceName = ""; if (completePathForIgnored) { // check the complete resource path resourceName = resourcePath; } else { // check only the resource name resourceName = CmsResource.getName(resourcePath); } while (i.hasNext()) { String ignoreFile = i.next(); if (resourceName.indexOf(ignoreFile) != -1) { // this file should be ignored return true; } } // file should be shown return false; } /** * Sorts 2 documents by the second sorting criteria (modification date) if the documents are in the same order.<p> * * @param orderValue the order value after sorting by the first criteria * @param d1 the first document * @param d2 the second document * @return the new order value after sorting by the second criteria */ protected static int orderBySecondCriteria(int orderValue, CmsDocument d1, CmsDocument d2) { if (orderValue == 0) { // objects are still in same order, use second criteria: modification date if (d1.getDateLastModified() > d2.getDateLastModified()) { return -1; } if (d1.getDateLastModified() < d2.getDateLastModified()) { return 1; } } return orderValue; } }