001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.documentlibrary.util;
016    
017    import com.liferay.portal.kernel.configuration.Filter;
018    import com.liferay.portal.kernel.exception.PortalException;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.log.Log;
021    import com.liferay.portal.kernel.log.LogFactoryUtil;
022    import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
023    import com.liferay.portal.kernel.portlet.LiferayWindowState;
024    import com.liferay.portal.kernel.repository.model.FileEntry;
025    import com.liferay.portal.kernel.repository.model.FileVersion;
026    import com.liferay.portal.kernel.repository.model.Folder;
027    import com.liferay.portal.kernel.search.Document;
028    import com.liferay.portal.kernel.search.Field;
029    import com.liferay.portal.kernel.search.Hits;
030    import com.liferay.portal.kernel.util.ArrayUtil;
031    import com.liferay.portal.kernel.util.GetterUtil;
032    import com.liferay.portal.kernel.util.HtmlUtil;
033    import com.liferay.portal.kernel.util.HttpUtil;
034    import com.liferay.portal.kernel.util.LocaleUtil;
035    import com.liferay.portal.kernel.util.LocalizationUtil;
036    import com.liferay.portal.kernel.util.OrderByComparator;
037    import com.liferay.portal.kernel.util.ParamUtil;
038    import com.liferay.portal.kernel.util.PrefsParamUtil;
039    import com.liferay.portal.kernel.util.PrefsPropsUtil;
040    import com.liferay.portal.kernel.util.PropsKeys;
041    import com.liferay.portal.kernel.util.PropsUtil;
042    import com.liferay.portal.kernel.util.SetUtil;
043    import com.liferay.portal.kernel.util.StringBundler;
044    import com.liferay.portal.kernel.util.StringPool;
045    import com.liferay.portal.kernel.util.StringUtil;
046    import com.liferay.portal.kernel.util.Validator;
047    import com.liferay.portal.kernel.util.WebKeys;
048    import com.liferay.portal.kernel.workflow.WorkflowConstants;
049    import com.liferay.portal.model.Group;
050    import com.liferay.portal.model.Subscription;
051    import com.liferay.portal.service.SubscriptionLocalServiceUtil;
052    import com.liferay.portal.service.WorkflowDefinitionLinkLocalServiceUtil;
053    import com.liferay.portal.theme.PortletDisplay;
054    import com.liferay.portal.theme.ThemeDisplay;
055    import com.liferay.portal.util.PortalUtil;
056    import com.liferay.portal.util.PortletKeys;
057    import com.liferay.portal.util.PropsValues;
058    import com.liferay.portlet.PortletPreferencesFactoryUtil;
059    import com.liferay.portlet.PortletURLFactoryUtil;
060    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
061    import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
062    import com.liferay.portlet.documentlibrary.model.DLFileEntryTypeConstants;
063    import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
064    import com.liferay.portlet.documentlibrary.model.DLFolder;
065    import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
066    import com.liferay.portlet.documentlibrary.service.DLAppLocalServiceUtil;
067    import com.liferay.portlet.documentlibrary.service.DLFolderLocalServiceUtil;
068    import com.liferay.portlet.documentlibrary.util.comparator.RepositoryModelCreateDateComparator;
069    import com.liferay.portlet.documentlibrary.util.comparator.RepositoryModelModifiedDateComparator;
070    import com.liferay.portlet.documentlibrary.util.comparator.RepositoryModelNameComparator;
071    import com.liferay.portlet.documentlibrary.util.comparator.RepositoryModelReadCountComparator;
072    import com.liferay.portlet.documentlibrary.util.comparator.RepositoryModelSizeComparator;
073    import com.liferay.portlet.messageboards.model.MBMessage;
074    import com.liferay.portlet.messageboards.service.MBMessageLocalServiceUtil;
075    import com.liferay.util.ContentUtil;
076    
077    import java.util.ArrayList;
078    import java.util.Arrays;
079    import java.util.Collections;
080    import java.util.Date;
081    import java.util.HashMap;
082    import java.util.HashSet;
083    import java.util.List;
084    import java.util.Locale;
085    import java.util.Map;
086    import java.util.Set;
087    import java.util.TreeSet;
088    
089    import javax.portlet.PortletPreferences;
090    import javax.portlet.PortletRequest;
091    import javax.portlet.PortletURL;
092    import javax.portlet.RenderResponse;
093    
094    import javax.servlet.http.HttpServletRequest;
095    
096    /**
097     * @author Brian Wing Shun Chan
098     * @author Julio Camarero
099     */
100    public class DLImpl implements DL {
101    
102            public void addPortletBreadcrumbEntries(
103                            DLFileShortcut dlFileShortcut, HttpServletRequest request,
104                            RenderResponse renderResponse)
105                    throws Exception {
106    
107                    Folder folder = dlFileShortcut.getFolder();
108    
109                    if (folder.getFolderId() !=
110                                    DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
111    
112                            addPortletBreadcrumbEntries(folder, request, renderResponse);
113                    }
114    
115                    DLFileShortcut unescapedDLFileShortcut =
116                            dlFileShortcut.toUnescapedModel();
117    
118                    PortletURL portletURL = renderResponse.createRenderURL();
119    
120                    portletURL.setParameter(
121                            "struts_action", "/document_library/view_file_entry");
122                    portletURL.setParameter(
123                            "fileEntryId", String.valueOf(dlFileShortcut.getToFileEntryId()));
124    
125                    PortalUtil.addPortletBreadcrumbEntry(
126                            request, unescapedDLFileShortcut.getToTitle(),
127                            portletURL.toString());
128            }
129    
130            public void addPortletBreadcrumbEntries(
131                            FileEntry fileEntry, HttpServletRequest request,
132                            RenderResponse renderResponse)
133                    throws Exception {
134    
135                    Folder folder = fileEntry.getFolder();
136    
137                    if (folder.getFolderId() !=
138                                    DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
139    
140                            addPortletBreadcrumbEntries(folder, request, renderResponse);
141                    }
142    
143                    PortletURL portletURL = renderResponse.createRenderURL();
144    
145                    FileEntry unescapedFileEntry = fileEntry.toUnescapedModel();
146    
147                    portletURL.setParameter(
148                            "struts_action", "/document_library/view_file_entry");
149                    portletURL.setParameter(
150                            "fileEntryId", String.valueOf(fileEntry.getFileEntryId()));
151    
152                    PortalUtil.addPortletBreadcrumbEntry(
153                            request, unescapedFileEntry.getTitle(), portletURL.toString());
154            }
155    
156            public void addPortletBreadcrumbEntries(
157                            Folder folder, HttpServletRequest request,
158                            LiferayPortletResponse liferayPortletResponse)
159                    throws Exception {
160    
161                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
162                            WebKeys.THEME_DISPLAY);
163    
164                    PortletURL portletURL = liferayPortletResponse.createRenderURL();
165    
166                    portletURL.setParameter("struts_action", "/document_library/view");
167    
168                    Map<String, Object> data = new HashMap<String, Object>();
169    
170                    data.put("direction-right", Boolean.TRUE.toString());
171                    data.put("folder-id", getDefaultFolderId(request));
172    
173                    PortalUtil.addPortletBreadcrumbEntry(
174                            request, themeDisplay.translate("home"), portletURL.toString(),
175                            data);
176    
177                    addPortletBreadcrumbEntries(folder, request, portletURL);
178            }
179    
180            public void addPortletBreadcrumbEntries(
181                            Folder folder, HttpServletRequest request, PortletURL portletURL)
182                    throws Exception {
183    
184                    long defaultFolderId = getDefaultFolderId(request);
185    
186                    List<Folder> ancestorFolders = Collections.emptyList();
187    
188                    if ((folder != null) && (folder.getFolderId() != defaultFolderId)) {
189                            ancestorFolders = folder.getAncestors();
190    
191                            int indexOfRootFolder = -1;
192    
193                            for (int i = 0; i < ancestorFolders.size(); i++) {
194                                    Folder ancestorFolder = ancestorFolders.get(i);
195    
196                                    if (defaultFolderId == ancestorFolder.getFolderId()) {
197                                            indexOfRootFolder = i;
198                                    }
199                            }
200    
201                            if (indexOfRootFolder > -1) {
202                                    ancestorFolders = ancestorFolders.subList(0, indexOfRootFolder);
203                            }
204                    }
205    
206                    Collections.reverse(ancestorFolders);
207    
208                    for (Folder ancestorFolder : ancestorFolders) {
209                            portletURL.setParameter(
210                                    "folderId", String.valueOf(ancestorFolder.getFolderId()));
211    
212                            Map<String, Object> data = new HashMap<String, Object>();
213    
214                            data.put("direction-right", Boolean.TRUE.toString());
215                            data.put("folder-id", ancestorFolder.getFolderId());
216    
217                            PortalUtil.addPortletBreadcrumbEntry(
218                                    request, ancestorFolder.getName(), portletURL.toString(), data);
219                    }
220    
221                    long folderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
222    
223                    if (folder != null) {
224                            folderId = folder.getFolderId();
225                    }
226    
227                    portletURL.setParameter("folderId", String.valueOf(folderId));
228    
229                    if ((folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
230                            (folderId != defaultFolderId)) {
231    
232                            Folder unescapedFolder = folder.toUnescapedModel();
233    
234                            Map<String, Object> data = new HashMap<String, Object>();
235    
236                            data.put("direction-right", Boolean.TRUE.toString());
237                            data.put("folder-id", folderId);
238    
239                            PortalUtil.addPortletBreadcrumbEntry(
240                                    request, unescapedFolder.getName(), portletURL.toString(),
241                                    data);
242                    }
243            }
244    
245            public void addPortletBreadcrumbEntries(
246                            Folder folder, HttpServletRequest request,
247                            RenderResponse renderResponse)
248                    throws Exception {
249    
250                    String strutsAction = ParamUtil.getString(request, "struts_action");
251    
252                    long groupId = ParamUtil.getLong(request, "groupId");
253    
254                    PortletURL portletURL = renderResponse.createRenderURL();
255    
256                    if (strutsAction.equals("/document_library/select_file_entry") ||
257                            strutsAction.equals("/document_library/select_folder") ||
258                            strutsAction.equals("/document_library_display/select_folder") ||
259                            strutsAction.equals(
260                                    "/dynamic_data_mapping/select_document_library") ||
261                            strutsAction.equals("/image_gallery_display/select_folder")) {
262    
263                            ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
264                                    WebKeys.THEME_DISPLAY);
265    
266                            portletURL.setWindowState(LiferayWindowState.POP_UP);
267    
268                            portletURL.setParameter("struts_action", strutsAction);
269                            portletURL.setParameter("groupId", String.valueOf(groupId));
270    
271                            PortalUtil.addPortletBreadcrumbEntry(
272                                    request, themeDisplay.translate("home"), portletURL.toString());
273                    }
274                    else {
275                            portletURL.setParameter("struts_action", "/document_library/view");
276                    }
277    
278                    addPortletBreadcrumbEntries(folder, request, portletURL);
279            }
280    
281            public void addPortletBreadcrumbEntries(
282                            long folderId, HttpServletRequest request,
283                            RenderResponse renderResponse)
284                    throws Exception {
285    
286                    if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
287                            Folder folder = DLAppLocalServiceUtil.getFolder(folderId);
288    
289                            if (folder.getFolderId() !=
290                                            DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
291    
292                                    addPortletBreadcrumbEntries(folder, request, renderResponse);
293                            }
294                    }
295            }
296    
297            public int compareVersions(String version1, String version2) {
298                    int[] splitVersion1 = StringUtil.split(version1, StringPool.PERIOD, 0);
299                    int[] splitVersion2 = StringUtil.split(version2, StringPool.PERIOD, 0);
300    
301                    if ((splitVersion1.length != 2) && (splitVersion2.length != 2)) {
302                            return 0;
303                    }
304                    else if (splitVersion1.length != 2) {
305                            return -1;
306                    }
307                    else if (splitVersion2.length != 2) {
308                            return 1;
309                    }
310    
311                    if (splitVersion1[0] > splitVersion2[0]) {
312                            return 1;
313                    }
314                    else if (splitVersion1[0] < splitVersion2[0]) {
315                            return -1;
316                    }
317                    else if (splitVersion1[1] > splitVersion2[1]) {
318                            return 1;
319                    }
320                    else if (splitVersion1[1] < splitVersion2[1]) {
321                            return -1;
322                    }
323    
324                    return 0;
325            }
326    
327            public String getAbsolutePath(PortletRequest portletRequest, long folderId)
328                    throws PortalException, SystemException {
329    
330                    ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
331                            WebKeys.THEME_DISPLAY);
332    
333                    if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
334                            return themeDisplay.translate("home");
335                    }
336    
337                    DLFolder dlFolder = DLFolderLocalServiceUtil.getFolder(folderId);
338    
339                    List<DLFolder> dlFolders = dlFolder.getAncestors();
340    
341                    Collections.reverse(dlFolders);
342    
343                    StringBundler sb = new StringBundler((dlFolders.size() * 3) + 5);
344    
345                    sb.append(themeDisplay.translate("home"));
346                    sb.append(StringPool.SPACE);
347    
348                    for (DLFolder curDLFolder : dlFolders) {
349                            sb.append(StringPool.RAQUO);
350                            sb.append(StringPool.SPACE);
351                            sb.append(curDLFolder.getName());
352                    }
353    
354                    sb.append(StringPool.RAQUO);
355                    sb.append(StringPool.SPACE);
356                    sb.append(dlFolder.getName());
357    
358                    return sb.toString();
359            }
360    
361            public Set<String> getAllMediaGalleryMimeTypes() {
362                    return _allMediaGalleryMimeTypes;
363            }
364    
365            public String getDDMStructureKey(DLFileEntryType dlFileEntryType) {
366                    return getDDMStructureKey(dlFileEntryType.getUuid());
367            }
368    
369            public String getDDMStructureKey(String fileEntryTypeUuid) {
370                    return "auto_" + fileEntryTypeUuid;
371            }
372    
373            public String getDeprecatedDDMStructureKey(
374                    DLFileEntryType dlFileEntryType) {
375    
376                    return getDeprecatedDDMStructureKey(
377                            dlFileEntryType.getFileEntryTypeId());
378            }
379    
380            public String getDeprecatedDDMStructureKey(long fileEntryTypeId) {
381                    return "auto_" + fileEntryTypeId;
382            }
383    
384            public String getDividedPath(long id) {
385                    StringBundler sb = new StringBundler(16);
386    
387                    long dividend = id;
388    
389                    while ((dividend / _DIVISOR) != 0) {
390                            sb.append(StringPool.SLASH);
391                            sb.append(dividend % _DIVISOR);
392    
393                            dividend = dividend / _DIVISOR;
394                    }
395    
396                    sb.append(StringPool.SLASH);
397                    sb.append(id);
398    
399                    return sb.toString();
400            }
401    
402            public String getDLControlPanelLink(
403                            PortletRequest portletRequest, long folderId)
404                    throws PortalException, SystemException {
405    
406                    ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
407                            WebKeys.THEME_DISPLAY);
408    
409                    PortletURL portletURL = PortletURLFactoryUtil.create(
410                            portletRequest, PortletKeys.DOCUMENT_LIBRARY,
411                            PortalUtil.getControlPanelPlid(themeDisplay.getCompanyId()),
412                            PortletRequest.RENDER_PHASE);
413    
414                    portletURL.setParameter("struts_action", "/document_library/view");
415                    portletURL.setParameter("folderId", String.valueOf(folderId));
416    
417                    return portletURL.toString();
418            }
419    
420            public Map<Locale, String> getEmailFileEntryAddedBodyMap(
421                    PortletPreferences preferences) {
422    
423                    Map<Locale, String> map = LocalizationUtil.getLocalizationMap(
424                            preferences, "emailFileEntryAddedBody");
425    
426                    Locale defaultLocale = LocaleUtil.getDefault();
427    
428                    String defaultValue = map.get(defaultLocale);
429    
430                    if (Validator.isNotNull(defaultValue)) {
431                            return map;
432                    }
433    
434                    map.put(
435                            defaultLocale,
436                            ContentUtil.get(
437                                    PropsUtil.get(PropsKeys.DL_EMAIL_FILE_ENTRY_ADDED_BODY)));
438    
439                    return map;
440            }
441    
442            public boolean getEmailFileEntryAddedEnabled(
443                    PortletPreferences preferences) {
444    
445                    String emailFileEntryAddedEnabled = preferences.getValue(
446                            "emailFileEntryAddedEnabled", StringPool.BLANK);
447    
448                    if (Validator.isNotNull(emailFileEntryAddedEnabled)) {
449                            return GetterUtil.getBoolean(emailFileEntryAddedEnabled);
450                    }
451                    else {
452                            return PropsValues.DL_EMAIL_FILE_ENTRY_ADDED_ENABLED;
453                    }
454            }
455    
456            public Map<Locale, String> getEmailFileEntryAddedSubjectMap(
457                    PortletPreferences preferences) {
458    
459                    Map<Locale, String> map = LocalizationUtil.getLocalizationMap(
460                            preferences, "emailFileEntryAddedSubject");
461    
462                    Locale defaultLocale = LocaleUtil.getDefault();
463    
464                    String defaultValue = map.get(defaultLocale);
465    
466                    if (Validator.isNotNull(defaultValue)) {
467                            return map;
468                    }
469    
470                    map.put(
471                            defaultLocale,
472                            ContentUtil.get(
473                                    PropsUtil.get(PropsKeys.DL_EMAIL_FILE_ENTRY_ADDED_SUBJECT)));
474    
475                    return map;
476            }
477    
478            public Map<Locale, String> getEmailFileEntryUpdatedBodyMap(
479                    PortletPreferences preferences) {
480    
481                    Map<Locale, String> map = LocalizationUtil.getLocalizationMap(
482                            preferences, "emailFileEntryUpdatedBody");
483    
484                    Locale defaultLocale = LocaleUtil.getDefault();
485    
486                    String defaultValue = map.get(defaultLocale);
487    
488                    if (Validator.isNotNull(defaultValue)) {
489                            return map;
490                    }
491    
492                    map.put(
493                            defaultLocale,
494                            ContentUtil.get(
495                                    PropsUtil.get(PropsKeys.DL_EMAIL_FILE_ENTRY_UPDATED_BODY)));
496    
497                    return map;
498            }
499    
500            public boolean getEmailFileEntryUpdatedEnabled(
501                    PortletPreferences preferences) {
502    
503                    String emailFileEntryUpdatedEnabled = preferences.getValue(
504                            "emailFileEntryUpdatedEnabled", StringPool.BLANK);
505    
506                    if (Validator.isNotNull(emailFileEntryUpdatedEnabled)) {
507                            return GetterUtil.getBoolean(emailFileEntryUpdatedEnabled);
508                    }
509                    else {
510                            return PropsValues.DL_EMAIL_FILE_ENTRY_UPDATED_ENABLED;
511                    }
512            }
513    
514            public Map<Locale, String> getEmailFileEntryUpdatedSubjectMap(
515                    PortletPreferences preferences) {
516    
517                    Map<Locale, String> map = LocalizationUtil.getLocalizationMap(
518                            preferences, "emailFileEntryUpdatedSubject");
519    
520                    Locale defaultLocale = LocaleUtil.getDefault();
521    
522                    String defaultValue = map.get(defaultLocale);
523    
524                    if (Validator.isNotNull(defaultValue)) {
525                            return map;
526                    }
527    
528                    map.put(
529                            defaultLocale,
530                            ContentUtil.get(
531                                    PropsUtil.get(PropsKeys.DL_EMAIL_FILE_ENTRY_UPDATED_SUBJECT)));
532    
533                    return map;
534            }
535    
536            public String getEmailFromAddress(
537                            PortletPreferences preferences, long companyId)
538                    throws SystemException {
539    
540                    return PortalUtil.getEmailFromAddress(
541                            preferences, companyId, PropsValues.DL_EMAIL_FROM_ADDRESS);
542            }
543    
544            public String getEmailFromName(
545                            PortletPreferences preferences, long companyId)
546                    throws SystemException {
547    
548                    return PortalUtil.getEmailFromName(
549                            preferences, companyId, PropsValues.DL_EMAIL_FROM_NAME);
550            }
551    
552            public List<Object> getEntries(Hits hits) {
553                    List<Object> entries = new ArrayList<Object>();
554    
555                    for (Document document : hits.getDocs()) {
556                            String entryClassName = GetterUtil.getString(
557                                    document.get(Field.ENTRY_CLASS_NAME));
558                            long entryClassPK = GetterUtil.getLong(
559                                    document.get(Field.ENTRY_CLASS_PK));
560    
561                            try {
562                                    Object obj = null;
563    
564                                    if (entryClassName.equals(DLFileEntry.class.getName())) {
565                                            obj = DLAppLocalServiceUtil.getFileEntry(entryClassPK);
566                                    }
567                                    else if (entryClassName.equals(MBMessage.class.getName())) {
568                                            long classPK = GetterUtil.getLong(
569                                                    document.get(Field.CLASS_PK));
570    
571                                            DLAppLocalServiceUtil.getFileEntry(classPK);
572    
573                                            obj = MBMessageLocalServiceUtil.getMessage(entryClassPK);
574                                    }
575    
576                                    entries.add(obj);
577                            }
578                            catch (Exception e) {
579                                    if (_log.isWarnEnabled()) {
580                                            _log.warn(
581                                                    "Documents and Media search index is stale and " +
582                                                            "contains entry {className=" + entryClassName +
583                                                                    ", classPK=" + entryClassPK + "}");
584                                    }
585                            }
586                    }
587    
588                    return entries;
589            }
590    
591            public String getFileEntryImage(
592                    FileEntry fileEntry, ThemeDisplay themeDisplay) {
593    
594                    StringBundler sb = new StringBundler(5);
595    
596                    sb.append("<img style=\"border-width: 0; text-align: left;\" src=\"");
597                    sb.append(themeDisplay.getPathThemeImages());
598                    sb.append("/file_system/small/");
599                    sb.append(fileEntry.getIcon());
600                    sb.append(".png\">");
601    
602                    return sb.toString();
603            }
604    
605            public Set<Long> getFileEntryTypeSubscriptionClassPKs(long userId)
606                    throws SystemException {
607    
608                    List<Subscription> subscriptions =
609                            SubscriptionLocalServiceUtil.getUserSubscriptions(
610                                    userId, DLFileEntryType.class.getName());
611    
612                    Set<Long> classPKs = new HashSet<Long>(subscriptions.size());
613    
614                    for (Subscription subscription : subscriptions) {
615                            classPKs.add(subscription.getClassPK());
616                    }
617    
618                    return classPKs;
619            }
620    
621            public String getFileIcon(String extension) {
622                    if (!_fileIcons.contains(extension)) {
623                            extension = _DEFAULT_FILE_ICON;
624                    }
625    
626                    return extension;
627            }
628    
629            public String getGenericName(String extension) {
630                    String genericName = _genericNames.get(extension);
631    
632                    if (genericName == null) {
633                            genericName = _DEFAULT_GENERIC_NAME;
634                    }
635    
636                    return genericName;
637            }
638    
639            public String[] getMediaGalleryMimeTypes(
640                    PortletPreferences portletPreferences, PortletRequest portletRequest) {
641    
642                    String mimeTypes = PrefsParamUtil.getString(
643                            portletPreferences, portletRequest, "mimeTypes",
644                            _allMediaGalleryMimeTypesString);
645    
646                    String[] mimeTypesArray = StringUtil.split(mimeTypes);
647    
648                    Arrays.sort(mimeTypesArray);
649    
650                    return mimeTypesArray;
651            }
652    
653            public String getPreviewURL(
654                    FileEntry fileEntry, FileVersion fileVersion, ThemeDisplay themeDisplay,
655                    String queryString) {
656    
657                    return getPreviewURL(
658                            fileEntry, fileVersion, themeDisplay, queryString, true, true);
659            }
660    
661            /**
662             * @deprecated {@link #getPreviewURL(FileEntry, FileVersion, ThemeDisplay,
663             *             String, boolean, boolean)}
664             */
665            public String getPreviewURL(
666                    FileEntry fileEntry, FileVersion fileVersion, ThemeDisplay themeDisplay,
667                    String queryString, boolean appendToken) {
668    
669                    return getPreviewURL(
670                            fileEntry, fileVersion, themeDisplay, queryString, true, true);
671            }
672    
673            public String getPreviewURL(
674                    FileEntry fileEntry, FileVersion fileVersion, ThemeDisplay themeDisplay,
675                    String queryString, boolean appendVersion, boolean absoluteURL) {
676    
677                    StringBundler sb = new StringBundler(17);
678    
679                    if (themeDisplay != null) {
680                            if (absoluteURL) {
681                                    sb.append(themeDisplay.getPortalURL());
682                            }
683                    }
684    
685                    sb.append(PortalUtil.getPathContext());
686                    sb.append("/documents/");
687                    sb.append(fileEntry.getRepositoryId());
688                    sb.append(StringPool.SLASH);
689                    sb.append(fileEntry.getFolderId());
690                    sb.append(StringPool.SLASH);
691                    sb.append(HttpUtil.encodeURL(HtmlUtil.unescape(fileEntry.getTitle())));
692                    sb.append(StringPool.SLASH);
693                    sb.append(fileEntry.getUuid());
694    
695                    if (appendVersion) {
696                            sb.append("?version=");
697                            sb.append(fileVersion.getVersion());
698                    }
699    
700                    if (ImageProcessorUtil.isImageSupported(fileVersion)) {
701                            if (appendVersion) {
702                                    sb.append("&t=");
703                            }
704                            else {
705                                    sb.append("?t=");
706                            }
707    
708                            Date modifiedDate = fileVersion.getModifiedDate();
709    
710                            sb.append(modifiedDate.getTime());
711                    }
712    
713                    sb.append(queryString);
714    
715                    if (themeDisplay != null) {
716                            PortletDisplay portletDisplay = themeDisplay.getPortletDisplay();
717    
718                            if (portletDisplay != null) {
719                                    String portletId = portletDisplay.getId();
720    
721                                    if (portletId.equals(PortletKeys.TRASH)) {
722                                            sb.append("&status=");
723                                            sb.append(WorkflowConstants.STATUS_IN_TRASH);
724                                    }
725                            }
726                    }
727    
728                    String previewURL = sb.toString();
729    
730                    if ((themeDisplay != null) && themeDisplay.isAddSessionIdToURL()) {
731                            return PortalUtil.getURLWithSessionId(
732                                    previewURL, themeDisplay.getSessionId());
733                    }
734    
735                    return previewURL;
736            }
737    
738            public OrderByComparator getRepositoryModelOrderByComparator(
739                    String orderByCol, String orderByType) {
740    
741                    boolean orderByAsc = true;
742    
743                    if (orderByType.equals("desc")) {
744                            orderByAsc = false;
745                    }
746    
747                    OrderByComparator orderByComparator = null;
748    
749                    if (orderByCol.equals("creationDate")) {
750                            orderByComparator = new RepositoryModelCreateDateComparator(
751                                    orderByAsc);
752                    }
753                    else if (orderByCol.equals("downloads")) {
754                            orderByComparator = new RepositoryModelReadCountComparator(
755                                    orderByAsc);
756                    }
757                    else if (orderByCol.equals("modifiedDate")) {
758                            orderByComparator = new RepositoryModelModifiedDateComparator(
759                                    orderByAsc);
760                    }
761                    else if (orderByCol.equals("size")) {
762                            orderByComparator = new RepositoryModelSizeComparator(orderByAsc);
763                    }
764                    else {
765                            orderByComparator = new RepositoryModelNameComparator(orderByAsc);
766                    }
767    
768                    return orderByComparator;
769            }
770    
771            public String getTempFileId(long id, String version) {
772                    return getTempFileId(id, version, null);
773            }
774    
775            public String getTempFileId(long id, String version, String languageId) {
776                    if (Validator.isNull(languageId)) {
777                            return String.valueOf(id).concat(StringPool.PERIOD).concat(version);
778                    }
779    
780                    StringBundler sb = new StringBundler(5);
781    
782                    sb.append(id);
783                    sb.append(StringPool.PERIOD);
784                    sb.append(version);
785                    sb.append(StringPool.PERIOD);
786                    sb.append(languageId);
787    
788                    return sb.toString();
789            }
790    
791            public String getThumbnailSrc(
792                            FileEntry fileEntry, DLFileShortcut dlFileShortcut,
793                            ThemeDisplay themeDisplay)
794                    throws Exception {
795    
796                    return getThumbnailSrc(
797                            fileEntry, fileEntry.getFileVersion(), dlFileShortcut,
798                            themeDisplay);
799            }
800    
801            public String getThumbnailSrc(
802                            FileEntry fileEntry, FileVersion fileVersion,
803                            DLFileShortcut dlFileShortcut, ThemeDisplay themeDisplay)
804                    throws Exception {
805    
806                    StringBundler sb = new StringBundler(4);
807    
808                    sb.append(themeDisplay.getPathThemeImages());
809                    sb.append("/file_system/large/");
810                    sb.append(getGenericName(fileEntry.getExtension()));
811                    sb.append(".png");
812    
813                    String thumbnailSrc = sb.toString();
814    
815                    String thumbnailQueryString = null;
816    
817                    if (GetterUtil.getBoolean(
818                                    PropsUtil.get(PropsKeys.DL_FILE_ENTRY_THUMBNAIL_ENABLED))) {
819    
820                            if (ImageProcessorUtil.hasImages(fileVersion)) {
821                                    thumbnailQueryString = "&imageThumbnail=1";
822                            }
823                            else if (PDFProcessorUtil.hasImages(fileVersion)) {
824                                    thumbnailQueryString = "&documentThumbnail=1";
825                            }
826                            else if (VideoProcessorUtil.hasVideo(fileVersion)) {
827                                    thumbnailQueryString = "&videoThumbnail=1";
828                            }
829                    }
830    
831                    if (Validator.isNotNull(thumbnailQueryString)) {
832                            thumbnailSrc = getPreviewURL(
833                                    fileEntry, fileVersion, themeDisplay, thumbnailQueryString,
834                                    true, true);
835                    }
836    
837                    return thumbnailSrc;
838            }
839    
840            public String getThumbnailStyle() throws Exception {
841                    return getThumbnailStyle(true, 0);
842            }
843    
844            public String getThumbnailStyle(boolean max, int margin) throws Exception {
845                    StringBundler sb = new StringBundler(5);
846    
847                    if (max) {
848                            sb.append("max-height: ");
849                    }
850                    else {
851                            sb.append("height: ");
852                    }
853    
854                    sb.append(
855                            PrefsPropsUtil.getLong(
856                                    PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_HEIGHT) + 2 * margin);
857    
858                    if (max) {
859                            sb.append("px; max-width: ");
860                    }
861                    else {
862                            sb.append("px; width: ");
863                    }
864    
865                    sb.append(
866                            PrefsPropsUtil.getLong(
867                                    PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_WIDTH) + 2 * margin);
868                    sb.append("px;");
869    
870                    return sb.toString();
871            }
872    
873            public String getTitleWithExtension(FileEntry fileEntry) {
874                    String title = fileEntry.getTitle();
875                    String extension = fileEntry.getExtension();
876    
877                    return getTitleWithExtension(title, extension);
878            }
879    
880            public String getTitleWithExtension(String title, String extension) {
881                    if (Validator.isNotNull(extension)) {
882                            String periodAndExtension = StringPool.PERIOD + extension;
883    
884                            if (!title.endsWith(periodAndExtension)) {
885                                    title += periodAndExtension;
886                            }
887                    }
888    
889                    return title;
890            }
891    
892            public String getWebDavURL(
893                            ThemeDisplay themeDisplay, Folder folder, FileEntry fileEntry)
894                    throws PortalException, SystemException {
895    
896                    return getWebDavURL(themeDisplay, folder, fileEntry, false);
897            }
898    
899            public String getWebDavURL(
900                            ThemeDisplay themeDisplay, Folder folder, FileEntry fileEntry,
901                            boolean manualCheckInRequired)
902                    throws PortalException, SystemException {
903    
904                    return getWebDavURL(
905                            themeDisplay, folder, fileEntry, manualCheckInRequired, false);
906            }
907    
908            public String getWebDavURL(
909                            ThemeDisplay themeDisplay, Folder folder, FileEntry fileEntry,
910                            boolean manualCheckInRequired, boolean openDocumentUrl)
911                    throws PortalException, SystemException {
912    
913                    StringBundler webDavURL = new StringBundler(8);
914    
915                    boolean secure = false;
916    
917                    if (themeDisplay.isSecure() ||
918                            PropsValues.WEBDAV_SERVLET_HTTPS_REQUIRED) {
919    
920                            secure = true;
921                    }
922    
923                    String portalURL = PortalUtil.getPortalURL(
924                            themeDisplay.getServerName(), themeDisplay.getServerPort(), secure);
925    
926                    webDavURL.append(portalURL);
927    
928                    webDavURL.append(themeDisplay.getPathContext());
929                    webDavURL.append("/webdav");
930    
931                    if (manualCheckInRequired) {
932                            webDavURL.append(DLUtil.MANUAL_CHECK_IN_REQUIRED_PATH);
933                    }
934    
935                    String fileEntryTitle = null;
936    
937                    if (fileEntry != null) {
938                            String extension = fileEntry.getExtension();
939    
940                            fileEntryTitle = fileEntry.getTitle();
941    
942                            if (openDocumentUrl && DLUtil.isOfficeExtension(extension) &&
943                                    !fileEntryTitle.endsWith(StringPool.PERIOD + extension)) {
944    
945                                    webDavURL.append(DLUtil.OFFICE_EXTENSION_PATH);
946    
947                                    fileEntryTitle += StringPool.PERIOD + extension;
948                            }
949                    }
950    
951                    Group group = themeDisplay.getScopeGroup();
952    
953                    webDavURL.append(group.getFriendlyURL());
954                    webDavURL.append("/document_library");
955    
956                    StringBuilder sb = new StringBuilder();
957    
958                    if (folder != null) {
959                            Folder curFolder = folder;
960    
961                            while (true) {
962                                    sb.insert(0, HttpUtil.encodeURL(curFolder.getName(), true));
963                                    sb.insert(0, StringPool.SLASH);
964    
965                                    if (curFolder.getParentFolderId() ==
966                                                    DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
967    
968                                            break;
969                                    }
970                                    else {
971                                            curFolder = DLAppLocalServiceUtil.getFolder(
972                                                    curFolder.getParentFolderId());
973                                    }
974                            }
975                    }
976    
977                    if (fileEntry != null) {
978                            sb.append(StringPool.SLASH);
979                            sb.append(HttpUtil.encodeURL(fileEntryTitle, true));
980                    }
981    
982                    webDavURL.append(sb.toString());
983    
984                    return webDavURL.toString();
985            }
986    
987            public boolean hasWorkflowDefinitionLink(
988                            long companyId, long groupId, long folderId, long fileEntryTypeId)
989                    throws Exception {
990    
991                    while (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
992                            DLFolder dlFolder = DLFolderLocalServiceUtil.fetchDLFolder(
993                                    folderId);
994    
995                            if (dlFolder == null) {
996                                    return false;
997                            }
998    
999                            if (dlFolder.isOverrideFileEntryTypes()) {
1000                                    break;
1001                            }
1002    
1003                            folderId = dlFolder.getParentFolderId();
1004                    }
1005    
1006                    if (WorkflowDefinitionLinkLocalServiceUtil.hasWorkflowDefinitionLink(
1007                                    companyId, groupId, DLFolderConstants.getClassName(), folderId,
1008                                    fileEntryTypeId) ||
1009                            WorkflowDefinitionLinkLocalServiceUtil.hasWorkflowDefinitionLink(
1010                                    companyId, groupId, DLFolderConstants.getClassName(), folderId,
1011                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL)) {
1012    
1013                            return true;
1014                    }
1015    
1016                    return false;
1017            }
1018    
1019            public boolean isAutoGeneratedDLFileEntryTypeDDMStructureKey(
1020                    String ddmStructureKey) {
1021    
1022                    if (ddmStructureKey.startsWith("auto_")) {
1023                            return true;
1024                    }
1025    
1026                    return false;
1027            }
1028    
1029            public boolean isOfficeExtension(String extension) {
1030                    if (extension.equalsIgnoreCase("doc") ||
1031                            extension.equalsIgnoreCase("docx") ||
1032                            extension.equalsIgnoreCase("dot") ||
1033                            extension.equalsIgnoreCase("ppt") ||
1034                            extension.equalsIgnoreCase("pptx") ||
1035                            extension.equalsIgnoreCase("xls") ||
1036                            extension.equalsIgnoreCase("xlsx")) {
1037    
1038                            return true;
1039                    }
1040    
1041                    return false;
1042            }
1043    
1044            public boolean isSubscribedToFileEntryType(
1045                            long companyId, long groupId, long userId, long fileEntryTypeId)
1046                    throws SystemException {
1047    
1048                    if (fileEntryTypeId ==
1049                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
1050    
1051                            fileEntryTypeId = groupId;
1052                    }
1053    
1054                    return SubscriptionLocalServiceUtil.isSubscribed(
1055                            companyId, userId, DLFileEntryType.class.getName(),
1056                            fileEntryTypeId);
1057            }
1058    
1059            public boolean isSubscribedToFolder(
1060                            long companyId, long groupId, long userId, long folderId)
1061                    throws PortalException, SystemException {
1062    
1063                    return isSubscribedToFolder(companyId, groupId, userId, folderId, true);
1064            }
1065    
1066            public boolean isSubscribedToFolder(
1067                            long companyId, long groupId, long userId, long folderId,
1068                            boolean recursive)
1069                    throws PortalException, SystemException {
1070    
1071                    List<Long> ancestorFolderIds = new ArrayList<Long>();
1072    
1073                    if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1074                            Folder folder = DLAppLocalServiceUtil.getFolder(folderId);
1075    
1076                            if (recursive) {
1077                                    ancestorFolderIds = folder.getAncestorFolderIds();
1078    
1079                                    ancestorFolderIds.add(groupId);
1080                            }
1081    
1082                            ancestorFolderIds.add(0, folderId);
1083                    }
1084                    else {
1085                            ancestorFolderIds.add(groupId);
1086                    }
1087    
1088                    long[] folderIdsArray = ArrayUtil.toLongArray(ancestorFolderIds);
1089    
1090                    return SubscriptionLocalServiceUtil.isSubscribed(
1091                            companyId, userId, Folder.class.getName(), folderIdsArray);
1092            }
1093    
1094            protected long getDefaultFolderId(HttpServletRequest request)
1095                    throws Exception {
1096    
1097                    PortletPreferences portletPreferences =
1098                            PortletPreferencesFactoryUtil.getPortletPreferences(
1099                                    request, PortalUtil.getPortletId(request));
1100    
1101                    return GetterUtil.getLong(
1102                            portletPreferences.getValue(
1103                                    "rootFolderId",
1104                                    String.valueOf(DLFolderConstants.DEFAULT_PARENT_FOLDER_ID)));
1105            }
1106    
1107            private static void _populateGenericNamesMap(String genericName) {
1108                    String[] extensions = PropsUtil.getArray(
1109                            PropsKeys.DL_FILE_GENERIC_EXTENSIONS, new Filter(genericName));
1110    
1111                    for (String extension : extensions) {
1112                            _genericNames.put(extension, genericName);
1113                    }
1114            }
1115    
1116            private static final String _DEFAULT_FILE_ICON = "page";
1117    
1118            private static final String _DEFAULT_GENERIC_NAME = "default";
1119    
1120            private static final long _DIVISOR = 256;
1121    
1122            private static Log _log = LogFactoryUtil.getLog(DLImpl.class);
1123    
1124            private static Set<String> _allMediaGalleryMimeTypes =
1125                    new TreeSet<String>();
1126            private static String _allMediaGalleryMimeTypesString;
1127            private static Set<String> _fileIcons = new HashSet<String>();
1128            private static Map<String, String> _genericNames =
1129                    new HashMap<String, String>();
1130    
1131            static {
1132                    _allMediaGalleryMimeTypes.addAll(
1133                            SetUtil.fromArray(
1134                                    PropsUtil.getArray(
1135                                            PropsKeys.DL_FILE_ENTRY_PREVIEW_AUDIO_MIME_TYPES)));
1136                    _allMediaGalleryMimeTypes.addAll(
1137                            SetUtil.fromArray(
1138                                    PropsUtil.getArray(
1139                                            PropsKeys.DL_FILE_ENTRY_PREVIEW_VIDEO_MIME_TYPES)));
1140                    _allMediaGalleryMimeTypes.addAll(
1141                            SetUtil.fromArray(
1142                                    PropsUtil.getArray(
1143                                            PropsKeys.DL_FILE_ENTRY_PREVIEW_IMAGE_MIME_TYPES)));
1144    
1145                    _allMediaGalleryMimeTypesString = StringUtil.merge(
1146                            _allMediaGalleryMimeTypes);
1147    
1148                    String[] fileIcons = null;
1149    
1150                    try {
1151                            fileIcons = PropsUtil.getArray(PropsKeys.DL_FILE_ICONS);
1152                    }
1153                    catch (Exception e) {
1154                            if (_log.isDebugEnabled()) {
1155                                    _log.debug(e, e);
1156                            }
1157    
1158                            fileIcons = new String[] {StringPool.BLANK};
1159                    }
1160    
1161                    for (int i = 0; i < fileIcons.length; i++) {
1162    
1163                            // Only process non wildcard extensions
1164    
1165                            if (!StringPool.STAR.equals(fileIcons[i])) {
1166    
1167                                    // Strip starting period
1168    
1169                                    String extension = fileIcons[i];
1170    
1171                                    if (extension.length() > 0) {
1172                                            extension = extension.substring(1);
1173                                    }
1174    
1175                                    _fileIcons.add(extension);
1176                            }
1177                    }
1178    
1179                    String[] genericNames = PropsUtil.getArray(
1180                            PropsKeys.DL_FILE_GENERIC_NAMES);
1181    
1182                    for (String genericName : genericNames) {
1183                            _populateGenericNamesMap(genericName);
1184                    }
1185            }
1186    
1187    }