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