1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portlet.documentlibrary.lar;
16  
17  import com.liferay.documentlibrary.service.DLLocalServiceUtil;
18  import com.liferay.portal.kernel.exception.PortalException;
19  import com.liferay.portal.kernel.exception.SystemException;
20  import com.liferay.portal.kernel.lar.BasePortletDataHandler;
21  import com.liferay.portal.kernel.lar.PortletDataContext;
22  import com.liferay.portal.kernel.lar.PortletDataException;
23  import com.liferay.portal.kernel.lar.PortletDataHandlerBoolean;
24  import com.liferay.portal.kernel.lar.PortletDataHandlerControl;
25  import com.liferay.portal.kernel.lar.PortletDataHandlerKeys;
26  import com.liferay.portal.kernel.log.Log;
27  import com.liferay.portal.kernel.log.LogFactoryUtil;
28  import com.liferay.portal.kernel.util.MapUtil;
29  import com.liferay.portal.kernel.util.StringBundler;
30  import com.liferay.portal.kernel.util.StringPool;
31  import com.liferay.portal.kernel.workflow.WorkflowConstants;
32  import com.liferay.portal.kernel.xml.Document;
33  import com.liferay.portal.kernel.xml.Element;
34  import com.liferay.portal.kernel.xml.SAXReaderUtil;
35  import com.liferay.portal.service.ServiceContext;
36  import com.liferay.portal.util.PortletKeys;
37  import com.liferay.portlet.documentlibrary.NoSuchFolderException;
38  import com.liferay.portlet.documentlibrary.model.DLFileEntry;
39  import com.liferay.portlet.documentlibrary.model.DLFileRank;
40  import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
41  import com.liferay.portlet.documentlibrary.model.DLFileVersion;
42  import com.liferay.portlet.documentlibrary.model.DLFolder;
43  import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
44  import com.liferay.portlet.documentlibrary.service.DLFileEntryLocalServiceUtil;
45  import com.liferay.portlet.documentlibrary.service.DLFileRankLocalServiceUtil;
46  import com.liferay.portlet.documentlibrary.service.DLFileShortcutLocalServiceUtil;
47  import com.liferay.portlet.documentlibrary.service.DLFileVersionLocalServiceUtil;
48  import com.liferay.portlet.documentlibrary.service.DLFolderLocalServiceUtil;
49  import com.liferay.portlet.documentlibrary.service.persistence.DLFileEntryUtil;
50  import com.liferay.portlet.documentlibrary.service.persistence.DLFileRankUtil;
51  import com.liferay.portlet.documentlibrary.service.persistence.DLFileShortcutUtil;
52  import com.liferay.portlet.documentlibrary.service.persistence.DLFolderUtil;
53  import com.liferay.portlet.documentlibrary.util.DLUtil;
54  
55  import java.io.IOException;
56  import java.io.InputStream;
57  
58  import java.util.List;
59  import java.util.Map;
60  import java.util.regex.Pattern;
61  
62  import javax.portlet.PortletPreferences;
63  
64  /**
65   * <a href="DLPortletDataHandlerImpl.java.html"><b><i>View Source</i></b></a>
66   *
67   * @author Bruno Farache
68   * @author Raymond Augé
69   */
70  public class DLPortletDataHandlerImpl extends BasePortletDataHandler {
71  
72      public static void exportFileEntry(
73              PortletDataContext context, Element foldersEl,
74              Element fileEntriesEl, Element fileRanksEl, DLFileEntry fileEntry)
75          throws PortalException, SystemException {
76  
77          if (!context.isWithinDateRange(fileEntry.getModifiedDate())) {
78              return;
79          }
80  
81          DLFileVersion fileVersion =
82              DLFileVersionLocalServiceUtil.getFileVersion(
83                  context.getGroupId(), fileEntry.getFolderId(),
84                  fileEntry.getName(), fileEntry.getVersion());
85  
86          if (fileVersion.getStatus() != WorkflowConstants.STATUS_APPROVED) {
87              return;
88          }
89  
90          if (foldersEl != null) {
91              exportParentFolder(context, foldersEl, fileEntry.getFolderId());
92          }
93  
94          String path = getFileEntryPath(context, fileEntry);
95  
96          if (context.isPathNotProcessed(path)) {
97              Element fileEntryEl = fileEntriesEl.addElement("file-entry");
98  
99              fileEntryEl.addAttribute("path", path);
100 
101             String binPath = getFileEntryBinPath(context, fileEntry);
102 
103             fileEntryEl.addAttribute("bin-path", binPath);
104 
105             fileEntry.setUserUuid(fileEntry.getUserUuid());
106 
107             context.addLocks(
108                 DLFileEntry.class,
109                 DLUtil.getLockId(
110                     fileEntry.getGroupId(), fileEntry.getFolderId(),
111                     fileEntry.getName()));
112 
113             context.addPermissions(
114                 DLFileEntry.class, fileEntry.getFileEntryId());
115 
116             if (context.getBooleanParameter(_NAMESPACE, "categories")) {
117                 context.addAssetCategories(
118                     DLFileEntry.class, fileEntry.getFileEntryId());
119             }
120 
121             if (context.getBooleanParameter(_NAMESPACE, "comments")) {
122                 context.addComments(
123                     DLFileEntry.class, fileEntry.getFileEntryId());
124             }
125 
126             if (context.getBooleanParameter(_NAMESPACE, "ratings")) {
127                 context.addRatingsEntries(
128                     DLFileEntry.class, fileEntry.getFileEntryId());
129             }
130 
131             if (context.getBooleanParameter(_NAMESPACE, "tags")) {
132                 context.addAssetTags(
133                     DLFileEntry.class, fileEntry.getFileEntryId());
134             }
135 
136             long repositoryId = getRepositoryId(
137                 fileEntry.getGroupId(), fileEntry.getFolderId());
138 
139             InputStream is = DLLocalServiceUtil.getFileAsStream(
140                 fileEntry.getCompanyId(), repositoryId, fileEntry.getName(),
141                 fileEntry.getVersion());
142 
143             if (is == null) {
144                 if (_log.isWarnEnabled()) {
145                     _log.warn(
146                         "No file found for file entry " +
147                             fileEntry.getFileEntryId());
148                 }
149 
150                 fileEntryEl.detach();
151 
152                 return;
153             }
154 
155             try {
156                 context.addZipEntry(
157                     getFileEntryBinPath(context, fileEntry), is);
158             }
159             finally {
160                 try {
161                     is.close();
162                 }
163                 catch (IOException ioe) {
164                     _log.error(ioe, ioe);
165                 }
166             }
167 
168             context.addZipEntry(path, fileEntry);
169 
170             if (context.getBooleanParameter(_NAMESPACE, "ranks")) {
171                 List<DLFileRank> fileRanks = DLFileRankUtil.findByF_N(
172                     fileEntry.getFolderId(), fileEntry.getName());
173 
174                 for (DLFileRank fileRank : fileRanks) {
175                     exportFileRank(context, fileRanksEl, fileRank);
176                 }
177             }
178         }
179     }
180 
181     public static void exportFolder(
182             PortletDataContext context, Element foldersEl,
183             Element fileEntriesEl, Element fileShortcutsEl, Element fileRanksEl,
184             DLFolder folder)
185         throws PortalException, SystemException {
186 
187         if (context.isWithinDateRange(folder.getModifiedDate())) {
188             exportParentFolder(context, foldersEl, folder.getParentFolderId());
189 
190             String path = getFolderPath(context, folder);
191 
192             if (context.isPathNotProcessed(path)) {
193                 Element folderEl = foldersEl.addElement("folder");
194 
195                 folderEl.addAttribute("path", path);
196 
197                 folder.setUserUuid(folder.getUserUuid());
198 
199                 context.addPermissions(DLFolder.class, folder.getFolderId());
200 
201                 context.addZipEntry(path, folder);
202             }
203         }
204 
205         List<DLFileEntry> fileEntries = DLFileEntryUtil.findByG_F(
206             folder.getGroupId(), folder.getFolderId());
207 
208         for (DLFileEntry fileEntry : fileEntries) {
209             exportFileEntry(
210                 context, foldersEl, fileEntriesEl, fileRanksEl, fileEntry);
211         }
212 
213         if (context.getBooleanParameter(_NAMESPACE, "shortcuts")) {
214             List<DLFileShortcut> fileShortcuts = DLFileShortcutUtil.findByG_F(
215                 folder.getGroupId(), folder.getFolderId());
216 
217             for (DLFileShortcut fileShortcut : fileShortcuts) {
218                 exportFileShortcut(
219                     context, foldersEl, fileShortcutsEl, fileShortcut);
220             }
221         }
222     }
223 
224     public static void importFileEntry(
225             PortletDataContext context, Map<Long, Long> folderPKs,
226             Map<String, String> fileEntryNames, DLFileEntry fileEntry,
227             String binPath)
228         throws Exception {
229 
230         long userId = context.getUserId(fileEntry.getUserUuid());
231         long groupId = context.getGroupId();
232         long folderId = MapUtil.getLong(
233             folderPKs, fileEntry.getFolderId(), fileEntry.getFolderId());
234 
235         long[] assetCategoryIds = null;
236         String[] assetTagNames = null;
237 
238         if (context.getBooleanParameter(_NAMESPACE, "categories")) {
239             assetCategoryIds = context.getAssetCategoryIds(
240                 DLFileEntry.class, fileEntry.getFileEntryId());
241         }
242 
243         if (context.getBooleanParameter(_NAMESPACE, "tags")) {
244             assetTagNames = context.getAssetTagNames(
245                 DLFileEntry.class, fileEntry.getFileEntryId());
246         }
247 
248         ServiceContext serviceContext = new ServiceContext();
249 
250         serviceContext.setAddCommunityPermissions(true);
251         serviceContext.setAddGuestPermissions(true);
252         serviceContext.setAssetCategoryIds(assetCategoryIds);
253         serviceContext.setAssetTagNames(assetTagNames);
254         serviceContext.setCreateDate(fileEntry.getCreateDate());
255         serviceContext.setModifiedDate(fileEntry.getModifiedDate());
256         serviceContext.setScopeGroupId(groupId);
257 
258         InputStream is = context.getZipEntryAsInputStream(binPath);
259 
260         if ((folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
261             (folderId == fileEntry.getFolderId())) {
262 
263             String path = getImportFolderPath(context, folderId);
264 
265             DLFolder folder = (DLFolder)context.getZipEntryAsObject(path);
266 
267             importFolder(context, folderPKs, folder);
268 
269             folderId = MapUtil.getLong(
270                 folderPKs, fileEntry.getFolderId(), fileEntry.getFolderId());
271         }
272 
273         DLFileEntry importedFileEntry = null;
274 
275         try {
276             if ((folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
277                 (folderId > 0)) {
278 
279                 DLFolderUtil.findByPrimaryKey(folderId);
280             }
281 
282             if (context.getDataStrategy().equals(
283                     PortletDataHandlerKeys.DATA_STRATEGY_MIRROR)) {
284 
285                 DLFileEntry existingFileEntry = DLFileEntryUtil.fetchByUUID_G(
286                     fileEntry.getUuid(), groupId);
287 
288                 if (existingFileEntry == null) {
289                     importedFileEntry =
290                         DLFileEntryLocalServiceUtil.addFileEntry(
291                             fileEntry.getUuid(), userId, groupId, folderId,
292                             fileEntry.getName(), fileEntry.getTitle(),
293                             fileEntry.getDescription(), null,
294                             fileEntry.getExtraSettings(), is,
295                             fileEntry.getSize(), serviceContext);
296                 }
297                 else if (!isDuplicateFileEntry(fileEntry, existingFileEntry)) {
298                     importedFileEntry =
299                         DLFileEntryLocalServiceUtil.updateFileEntry(
300                             userId, groupId, existingFileEntry.getFolderId(),
301                             folderId, existingFileEntry.getName(),
302                             fileEntry.getTitle(), fileEntry.getTitle(),
303                             fileEntry.getDescription(), null, true,
304                             fileEntry.getExtraSettings(), is,
305                             fileEntry.getSize(), serviceContext);
306                 }
307             }
308             else {
309                 importedFileEntry = DLFileEntryLocalServiceUtil.addFileEntry(
310                     null, userId, groupId, folderId, fileEntry.getName(),
311                     fileEntry.getTitle(), fileEntry.getDescription(), null,
312                     fileEntry.getExtraSettings(), is, fileEntry.getSize(),
313                     serviceContext);
314             }
315 
316             fileEntryNames.put(
317                 fileEntry.getName(), importedFileEntry.getName());
318 
319             String lockKey = DLUtil.getLockId(
320                 fileEntry.getGroupId(), fileEntry.getFolderId(),
321                 fileEntry.getName());
322 
323             String newLockKey = DLUtil.getLockId(
324                 importedFileEntry.getGroupId(), importedFileEntry.getFolderId(),
325                 importedFileEntry.getName());
326 
327             context.importLocks(DLFileEntry.class, lockKey, newLockKey);
328 
329             context.importPermissions(
330                 DLFileEntry.class, fileEntry.getFileEntryId(),
331                 importedFileEntry.getFileEntryId());
332 
333             if (context.getBooleanParameter(_NAMESPACE, "comments")) {
334                 context.importComments(
335                     DLFileEntry.class, fileEntry.getFileEntryId(),
336                     importedFileEntry.getFileEntryId(), groupId);
337             }
338 
339             if (context.getBooleanParameter(_NAMESPACE, "ratings")) {
340                 context.importRatingsEntries(
341                     DLFileEntry.class, fileEntry.getFileEntryId(),
342                     importedFileEntry.getFileEntryId());
343             }
344         }
345         catch (NoSuchFolderException nsfe) {
346             _log.error(
347                 "Could not find the parent folder for entry " +
348                     fileEntry.getFileEntryId());
349         }
350     }
351 
352     public static void importFileRank(
353             PortletDataContext context, Map<Long, Long> folderPKs,
354             Map<String, String> fileEntryNames, DLFileRank rank)
355         throws Exception {
356 
357         long userId = context.getUserId(rank.getUserUuid());
358         long folderId = MapUtil.getLong(
359             folderPKs, rank.getFolderId(), rank.getFolderId());
360 
361         String name = fileEntryNames.get(rank.getName());
362 
363         if (name == null) {
364             name = rank.getName();
365         }
366 
367         ServiceContext serviceContext = new ServiceContext();
368 
369         serviceContext.setCreateDate(rank.getCreateDate());
370 
371         if ((folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
372             (folderId == rank.getFolderId())) {
373 
374             String path = getImportFolderPath(context, folderId);
375 
376             DLFolder folder = (DLFolder)context.getZipEntryAsObject(path);
377 
378             importFolder(context, folderPKs, folder);
379 
380             folderId = MapUtil.getLong(
381                 folderPKs, rank.getFolderId(), rank.getFolderId());
382         }
383 
384         try {
385             DLFolderUtil.findByPrimaryKey(folderId);
386 
387             DLFileRankLocalServiceUtil.updateFileRank(
388                 context.getGroupId(), context.getCompanyId(), userId, folderId,
389                 name, serviceContext);
390         }
391         catch (NoSuchFolderException nsfe) {
392             _log.error(
393                 "Could not find the folder for rank " + rank.getFileRankId());
394         }
395     }
396 
397     public static void importFolder(
398             PortletDataContext context, Map<Long, Long> folderPKs,
399             DLFolder folder)
400         throws Exception {
401 
402         long userId = context.getUserId(folder.getUserUuid());
403         long groupId = context.getGroupId();
404         long parentFolderId = MapUtil.getLong(
405             folderPKs, folder.getParentFolderId(), folder.getParentFolderId());
406 
407         ServiceContext serviceContext = new ServiceContext();
408 
409         serviceContext.setAddCommunityPermissions(true);
410         serviceContext.setAddGuestPermissions(true);
411         serviceContext.setCreateDate(folder.getCreateDate());
412         serviceContext.setModifiedDate(folder.getModifiedDate());
413 
414         if ((parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
415             (parentFolderId == folder.getParentFolderId())) {
416 
417             String path = getImportFolderPath(context, parentFolderId);
418 
419             DLFolder parentFolder = (DLFolder)context.getZipEntryAsObject(path);
420 
421             importFolder(context, folderPKs, parentFolder);
422 
423             parentFolderId = MapUtil.getLong(
424                 folderPKs, folder.getParentFolderId(),
425                 folder.getParentFolderId());
426         }
427 
428         DLFolder importedFolder = null;
429 
430         try {
431             if (parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
432                 DLFolderUtil.findByPrimaryKey(parentFolderId);
433             }
434 
435             if (context.getDataStrategy().equals(
436                     PortletDataHandlerKeys.DATA_STRATEGY_MIRROR)) {
437 
438                 DLFolder existingFolder = DLFolderUtil.fetchByUUID_G(
439                     folder.getUuid(), groupId);
440 
441                 if (existingFolder == null) {
442                     String name = getFolderName(
443                         context.getCompanyId(), groupId, parentFolderId,
444                         folder.getName(), 2);
445 
446                     importedFolder = DLFolderLocalServiceUtil.addFolder(
447                         folder.getUuid(), userId, groupId, parentFolderId,
448                         name, folder.getDescription(), serviceContext);
449                 }
450                 else {
451                     importedFolder = DLFolderLocalServiceUtil.updateFolder(
452                         existingFolder.getFolderId(), parentFolderId,
453                         folder.getName(), folder.getDescription(),
454                         serviceContext);
455                 }
456             }
457             else {
458                 String name = getFolderName(
459                     context.getCompanyId(), groupId, parentFolderId,
460                     folder.getName(), 2);
461 
462                 importedFolder = DLFolderLocalServiceUtil.addFolder(
463                     null, userId, groupId, parentFolderId, name,
464                     folder.getDescription(), serviceContext);
465             }
466 
467             folderPKs.put(folder.getFolderId(), importedFolder.getFolderId());
468 
469             context.importPermissions(
470                 DLFolder.class, folder.getFolderId(),
471                 importedFolder.getFolderId());
472         }
473         catch (NoSuchFolderException nsfe) {
474             _log.error(
475                 "Could not find the parent folder for folder " +
476                     folder.getFolderId());
477         }
478     }
479 
480     public PortletPreferences deleteData(
481             PortletDataContext context, String portletId,
482             PortletPreferences preferences)
483         throws PortletDataException {
484 
485         try {
486             if (!context.addPrimaryKey(
487                     DLPortletDataHandlerImpl.class, "deleteData")) {
488 
489                 DLFolderLocalServiceUtil.deleteFolders(context.getGroupId());
490             }
491 
492             return null;
493         }
494         catch (Exception e) {
495             throw new PortletDataException(e);
496         }
497     }
498 
499     public String exportData(
500             PortletDataContext context, String portletId,
501             PortletPreferences preferences)
502         throws PortletDataException {
503 
504         try {
505             Document doc = SAXReaderUtil.createDocument();
506 
507             Element root = doc.addElement("documentlibrary-data");
508 
509             root.addAttribute("group-id", String.valueOf(context.getGroupId()));
510 
511             Element foldersEl = root.addElement("folders");
512             Element fileEntriesEl = root.addElement("file-entries");
513             Element fileShortcutsEl = root.addElement("file-shortcuts");
514             Element fileRanksEl = root.addElement("file-ranks");
515 
516             List<DLFolder> folders = DLFolderUtil.findByGroupId(
517                 context.getGroupId());
518 
519             for (DLFolder folder : folders) {
520                 exportFolder(
521                     context, foldersEl, fileEntriesEl, fileShortcutsEl,
522                     fileRanksEl, folder);
523             }
524 
525             List<DLFileEntry> fileEntries = DLFileEntryUtil.findByG_F(
526                 context.getGroupId(),
527                 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
528 
529             for (DLFileEntry fileEntry : fileEntries) {
530                 exportFileEntry(
531                     context, foldersEl, fileEntriesEl, fileRanksEl, fileEntry);
532             }
533 
534             return doc.formattedString();
535         }
536         catch (Exception e) {
537             throw new PortletDataException(e);
538         }
539     }
540 
541     public PortletDataHandlerControl[] getExportControls() {
542         return new PortletDataHandlerControl[] {
543             _foldersAndDocuments, _shortcuts, _ranks, _categories, _comments,
544             _ratings, _tags
545         };
546     }
547 
548     public PortletDataHandlerControl[] getImportControls() {
549         return new PortletDataHandlerControl[] {
550             _foldersAndDocuments, _shortcuts, _ranks, _categories, _comments,
551             _ratings, _tags
552         };
553     }
554 
555     public PortletPreferences importData(
556             PortletDataContext context, String portletId,
557             PortletPreferences preferences, String data)
558         throws PortletDataException {
559 
560         try {
561             Document doc = SAXReaderUtil.read(data);
562 
563             Element root = doc.getRootElement();
564 
565             List<Element> folderEls = root.element("folders").elements(
566                 "folder");
567 
568             Map<Long, Long> folderPKs =
569                 (Map<Long, Long>)context.getNewPrimaryKeysMap(DLFolder.class);
570 
571             for (Element folderEl : folderEls) {
572                 String path = folderEl.attributeValue("path");
573 
574                 if (!context.isPathNotProcessed(path)) {
575                     continue;
576                 }
577 
578                 DLFolder folder = (DLFolder)context.getZipEntryAsObject(path);
579 
580                 importFolder(context, folderPKs, folder);
581             }
582 
583             List<Element> fileEntryEls = root.element("file-entries").elements(
584                 "file-entry");
585 
586             Map<String, String> fileEntryNames =
587                 (Map<String, String>)context.getNewPrimaryKeysMap(
588                     DLFileEntry.class);
589 
590             for (Element fileEntryEl : fileEntryEls) {
591                 String path = fileEntryEl.attributeValue("path");
592 
593                 if (!context.isPathNotProcessed(path)) {
594                     continue;
595                 }
596 
597                 DLFileEntry fileEntry =
598                     (DLFileEntry)context.getZipEntryAsObject(path);
599 
600                 String binPath = fileEntryEl.attributeValue("bin-path");
601 
602                 importFileEntry(
603                     context, folderPKs, fileEntryNames, fileEntry, binPath);
604             }
605 
606             if (context.getBooleanParameter(_NAMESPACE, "shortcuts")) {
607                 List<Element> fileShortcutEls = root.element(
608                     "file-shortcuts").elements("file-shortcut");
609 
610                 for (Element fileShortcutEl : fileShortcutEls) {
611                     String path = fileShortcutEl.attributeValue("path");
612 
613                     if (!context.isPathNotProcessed(path)) {
614                         continue;
615                     }
616 
617                     DLFileShortcut fileShortcut =
618                         (DLFileShortcut)context.getZipEntryAsObject(path);
619 
620                     importFileShortcut(
621                         context, folderPKs, fileEntryNames, fileShortcut);
622                 }
623             }
624 
625             if (context.getBooleanParameter(_NAMESPACE, "ranks")) {
626                 List<Element> fileRankEls = root.element("file-ranks").elements(
627                     "file-rank");
628 
629                 for (Element fileRankEl : fileRankEls) {
630                     String path = fileRankEl.attributeValue("path");
631 
632                     if (!context.isPathNotProcessed(path)) {
633                         continue;
634                     }
635 
636                     DLFileRank fileRank =
637                         (DLFileRank)context.getZipEntryAsObject(path);
638 
639                     importFileRank(
640                         context, folderPKs, fileEntryNames, fileRank);
641                 }
642             }
643 
644             return null;
645         }
646         catch (Exception e) {
647             throw new PortletDataException(e);
648         }
649     }
650 
651     protected static void exportFileRank(
652             PortletDataContext context, Element fileRanksEl,
653             DLFileRank fileRank)
654         throws SystemException {
655 
656         String path = getFileRankPath(context, fileRank);
657 
658         if (!context.isPathNotProcessed(path)) {
659             return;
660         }
661 
662         Element fileRankEl = fileRanksEl.addElement("file-rank");
663 
664         fileRankEl.addAttribute("path", path);
665 
666         fileRank.setUserUuid(fileRank.getUserUuid());
667 
668         context.addZipEntry(path, fileRank);
669     }
670 
671     protected static void exportFileShortcut(
672             PortletDataContext context, Element foldersEl,
673             Element fileShortcutsEl, DLFileShortcut fileShortcut)
674         throws PortalException, SystemException {
675 
676         exportParentFolder(context, foldersEl, fileShortcut.getFolderId());
677 
678         String path = getFileShortcutPath(context, fileShortcut);
679 
680         if (context.isPathNotProcessed(path)) {
681             Element fileShortcutEl = fileShortcutsEl.addElement(
682                 "file-shortcut");
683 
684             fileShortcutEl.addAttribute("path", path);
685 
686             fileShortcut.setUserUuid(fileShortcut.getUserUuid());
687 
688             context.addPermissions(
689                 DLFileShortcut.class, fileShortcut.getFileShortcutId());
690 
691             context.addZipEntry(path, fileShortcut);
692         }
693     }
694 
695     protected static void exportParentFolder(
696             PortletDataContext context, Element foldersEl, long folderId)
697         throws PortalException, SystemException {
698 
699         if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
700             return;
701         }
702 
703         DLFolder folder = DLFolderUtil.findByPrimaryKey(folderId);
704 
705         exportParentFolder(context, foldersEl, folder.getParentFolderId());
706 
707         String path = getFolderPath(context, folder);
708 
709         if (context.isPathNotProcessed(path)) {
710             Element folderEl = foldersEl.addElement("folder");
711 
712             folderEl.addAttribute("path", path);
713 
714             folder.setUserUuid(folder.getUserUuid());
715 
716             context.addPermissions(DLFolder.class, folder.getFolderId());
717 
718             context.addZipEntry(path, folder);
719         }
720     }
721 
722     protected static String getFileEntryBinPath(
723         PortletDataContext context, DLFileEntry fileEntry) {
724 
725         StringBundler sb = new StringBundler(5);
726 
727         sb.append(context.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
728         sb.append("/bin/");
729         sb.append(fileEntry.getFileEntryId());
730         sb.append(StringPool.SLASH);
731         sb.append(fileEntry.getVersion());
732 
733         return sb.toString();
734     }
735 
736     protected static String getFileEntryPath(
737         PortletDataContext context, DLFileEntry fileEntry) {
738 
739         StringBundler sb = new StringBundler(6);
740 
741         sb.append(context.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
742         sb.append("/file-entries/");
743         sb.append(fileEntry.getFileEntryId());
744         sb.append(StringPool.SLASH);
745         sb.append(fileEntry.getVersion());
746         sb.append(".xml");
747 
748         return sb.toString();
749     }
750 
751     protected static String getFolderName(
752             long companyId, long groupId, long parentFolderId, String name,
753             int count)
754         throws SystemException {
755 
756         DLFolder folder = DLFolderUtil.fetchByG_P_N(
757             groupId, parentFolderId, name);
758 
759         if (folder == null) {
760             return name;
761         }
762 
763         if (Pattern.matches(".* \\(\\d+\\)", name)) {
764             int pos = name.lastIndexOf(" (");
765 
766             name = name.substring(0, pos);
767         }
768 
769         StringBundler sb = new StringBundler(5);
770 
771         sb.append(name);
772         sb.append(StringPool.SPACE);
773         sb.append(StringPool.OPEN_PARENTHESIS);
774         sb.append(count);
775         sb.append(StringPool.CLOSE_PARENTHESIS);
776 
777         name = sb.toString();
778 
779         return getFolderName(companyId, groupId, parentFolderId, name, ++count);
780     }
781 
782     protected static String getFolderPath(
783         PortletDataContext context, DLFolder folder) {
784 
785         StringBundler sb = new StringBundler(4);
786 
787         sb.append(context.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
788         sb.append("/folders/");
789         sb.append(folder.getFolderId());
790         sb.append(".xml");
791 
792         return sb.toString();
793     }
794 
795     protected static String getFileRankPath(
796         PortletDataContext context, DLFileRank fileRank) {
797 
798         StringBundler sb = new StringBundler(4);
799 
800         sb.append(context.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
801         sb.append("/ranks/");
802         sb.append(fileRank.getFileRankId());
803         sb.append(".xml");
804 
805         return sb.toString();
806     }
807 
808     protected static String getFileShortcutPath(
809         PortletDataContext context, DLFileShortcut fileShortcut) {
810 
811         StringBundler sb = new StringBundler(4);
812 
813         sb.append(context.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
814         sb.append("/shortcuts/");
815         sb.append(fileShortcut.getFileShortcutId());
816         sb.append(".xml");
817 
818         return sb.toString();
819     }
820 
821     protected static String getImportFolderPath(
822         PortletDataContext context, long folderId) {
823 
824         StringBundler sb = new StringBundler(4);
825 
826         sb.append(context.getSourcePortletPath(PortletKeys.DOCUMENT_LIBRARY));
827         sb.append("/folders/");
828         sb.append(folderId);
829         sb.append(".xml");
830 
831         return sb.toString();
832     }
833 
834     protected static long getRepositoryId(long groupId, long folderId) {
835         if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
836             return groupId;
837         }
838         else {
839             return folderId;
840         }
841     }
842 
843     protected static void importFileShortcut(
844             PortletDataContext context, Map<Long, Long> folderPKs,
845             Map<String, String> fileEntryNames, DLFileShortcut fileShortcut)
846         throws Exception {
847 
848         long userId = context.getUserId(fileShortcut.getUserUuid());
849         long folderId = MapUtil.getLong(
850             folderPKs, fileShortcut.getFolderId(), fileShortcut.getFolderId());
851         long toFolderId = MapUtil.getLong(
852             folderPKs, fileShortcut.getToFolderId(),
853             fileShortcut.getToFolderId());
854         String toName = MapUtil.getString(
855             fileEntryNames, fileShortcut.getToName(), fileShortcut.getToName());
856 
857         try {
858             DLFolder folder = DLFolderUtil.findByPrimaryKey(folderId);
859             DLFolderUtil.findByPrimaryKey(toFolderId);
860 
861             long groupId = folder.getGroupId();
862 
863             DLFileEntry fileEntry = DLFileEntryLocalServiceUtil.getFileEntry(
864                 groupId, toFolderId, toName);
865 
866             long[] assetCategoryIds = null;
867             String[] assetTagNames = null;
868 
869             if (context.getBooleanParameter(_NAMESPACE, "categories")) {
870                 assetCategoryIds = context.getAssetCategoryIds(
871                     DLFileEntry.class, fileEntry.getFileEntryId());
872             }
873 
874             if (context.getBooleanParameter(_NAMESPACE, "tags")) {
875                 assetTagNames = context.getAssetTagNames(
876                     DLFileEntry.class, fileEntry.getFileEntryId());
877             }
878 
879             ServiceContext serviceContext = new ServiceContext();
880 
881             serviceContext.setAddCommunityPermissions(true);
882             serviceContext.setAddGuestPermissions(true);
883             serviceContext.setAssetCategoryIds(assetCategoryIds);
884             serviceContext.setAssetTagNames(assetTagNames);
885             serviceContext.setCreateDate(fileShortcut.getCreateDate());
886             serviceContext.setModifiedDate(fileShortcut.getModifiedDate());
887             serviceContext.setScopeGroupId(context.getGroupId());
888 
889             DLFileShortcut importedFileShortcut = null;
890 
891             if (context.getDataStrategy().equals(
892                     PortletDataHandlerKeys.DATA_STRATEGY_MIRROR)) {
893 
894                 DLFileShortcut existingFileShortcut =
895                     DLFileShortcutUtil.fetchByUUID_G(
896                         fileShortcut.getUuid(), context.getGroupId());
897 
898                 if (existingFileShortcut == null) {
899                     importedFileShortcut =
900                         DLFileShortcutLocalServiceUtil.addFileShortcut(
901                             fileShortcut.getUuid(), userId, groupId, folderId,
902                             toFolderId, toName, serviceContext);
903                 }
904                 else {
905                     importedFileShortcut =
906                         DLFileShortcutLocalServiceUtil.updateFileShortcut(
907                             userId, existingFileShortcut.getFileShortcutId(),
908                             folderId, toFolderId, toName, serviceContext);
909                 }
910             }
911             else {
912                 importedFileShortcut =
913                     DLFileShortcutLocalServiceUtil.addFileShortcut(
914                         null, userId, groupId, folderId, toFolderId, toName,
915                         serviceContext);
916             }
917 
918             context.importPermissions(
919                 DLFileShortcut.class, fileShortcut.getPrimaryKey(),
920                 importedFileShortcut.getPrimaryKey());
921         }
922         catch (NoSuchFolderException nsfe) {
923             _log.error(
924                 "Could not find the folder for shortcut " +
925                     fileShortcut.getFileShortcutId());
926         }
927     }
928 
929     protected static boolean isDuplicateFileEntry(
930         DLFileEntry fileEntry1, DLFileEntry fileEntry2) {
931 
932         try {
933             DLFolder folder1 = fileEntry1.getFolder();
934             DLFolder folder2 = fileEntry2.getFolder();
935 
936             if ((folder1.getUuid().equals(folder2.getUuid())) &&
937                 (fileEntry1.getSize() == fileEntry2.getSize()) &&
938                 (DLUtil.compareVersions(
939                     fileEntry1.getVersion(), fileEntry2.getVersion()) == 0) &&
940                 (fileEntry1.getVersionUserUuid().equals(
941                     fileEntry2.getVersionUserUuid()))) {
942 
943                 return true;
944             }
945             else {
946                 return false;
947             }
948         }
949         catch (SystemException se) {
950             return false;
951         }
952     }
953 
954     private static final String _NAMESPACE = "document_library";
955 
956     private static Log _log = LogFactoryUtil.getLog(
957         DLPortletDataHandlerImpl.class);
958 
959     private static PortletDataHandlerBoolean _categories =
960         new PortletDataHandlerBoolean(_NAMESPACE, "categories");
961 
962     private static PortletDataHandlerBoolean _comments =
963         new PortletDataHandlerBoolean(_NAMESPACE, "comments");
964 
965     private static PortletDataHandlerBoolean _foldersAndDocuments =
966         new PortletDataHandlerBoolean(
967             _NAMESPACE, "folders-and-documents", true, true);
968 
969     private static PortletDataHandlerBoolean _ranks =
970         new PortletDataHandlerBoolean(_NAMESPACE, "ranks");
971 
972     private static PortletDataHandlerBoolean _ratings =
973         new PortletDataHandlerBoolean(_NAMESPACE, "ratings");
974 
975     private static PortletDataHandlerBoolean _shortcuts=
976         new PortletDataHandlerBoolean(_NAMESPACE, "shortcuts");
977 
978     private static PortletDataHandlerBoolean _tags =
979         new PortletDataHandlerBoolean(_NAMESPACE, "tags");
980 
981 }