001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.documentlibrary.lar;
016    
017    import com.liferay.documentlibrary.DuplicateFileException;
018    import com.liferay.documentlibrary.service.DLLocalServiceUtil;
019    import com.liferay.portal.kernel.lar.BasePortletDataHandler;
020    import com.liferay.portal.kernel.lar.PortletDataContext;
021    import com.liferay.portal.kernel.lar.PortletDataHandlerBoolean;
022    import com.liferay.portal.kernel.lar.PortletDataHandlerControl;
023    import com.liferay.portal.kernel.log.Log;
024    import com.liferay.portal.kernel.log.LogFactoryUtil;
025    import com.liferay.portal.kernel.search.Indexer;
026    import com.liferay.portal.kernel.search.IndexerRegistryUtil;
027    import com.liferay.portal.kernel.util.MapUtil;
028    import com.liferay.portal.kernel.util.StringBundler;
029    import com.liferay.portal.kernel.util.StringPool;
030    import com.liferay.portal.kernel.workflow.WorkflowConstants;
031    import com.liferay.portal.kernel.xml.Document;
032    import com.liferay.portal.kernel.xml.Element;
033    import com.liferay.portal.kernel.xml.SAXReaderUtil;
034    import com.liferay.portal.service.ServiceContext;
035    import com.liferay.portal.util.PortletKeys;
036    import com.liferay.portal.util.PropsValues;
037    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
038    import com.liferay.portlet.documentlibrary.model.DLFileRank;
039    import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
040    import com.liferay.portlet.documentlibrary.model.DLFileVersion;
041    import com.liferay.portlet.documentlibrary.model.DLFolder;
042    import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
043    import com.liferay.portlet.documentlibrary.service.DLFileEntryLocalServiceUtil;
044    import com.liferay.portlet.documentlibrary.service.DLFileRankLocalServiceUtil;
045    import com.liferay.portlet.documentlibrary.service.DLFileShortcutLocalServiceUtil;
046    import com.liferay.portlet.documentlibrary.service.DLFileVersionLocalServiceUtil;
047    import com.liferay.portlet.documentlibrary.service.DLFolderLocalServiceUtil;
048    import com.liferay.portlet.documentlibrary.service.persistence.DLFileEntryUtil;
049    import com.liferay.portlet.documentlibrary.service.persistence.DLFileRankUtil;
050    import com.liferay.portlet.documentlibrary.service.persistence.DLFileShortcutUtil;
051    import com.liferay.portlet.documentlibrary.service.persistence.DLFolderUtil;
052    import com.liferay.portlet.documentlibrary.util.DLUtil;
053    import com.liferay.util.PwdGenerator;
054    
055    import java.io.IOException;
056    import java.io.InputStream;
057    
058    import java.util.List;
059    import java.util.Map;
060    import java.util.regex.Pattern;
061    
062    import javax.portlet.PortletPreferences;
063    
064    /**
065     * @author Bruno Farache
066     * @author Raymond Augé
067     */
068    public class DLPortletDataHandlerImpl extends BasePortletDataHandler {
069    
070            public static void exportFileEntry(
071                            PortletDataContext context, Element foldersElement,
072                            Element fileEntriesElement, Element fileRanksElement,
073                            DLFileEntry fileEntry, boolean checkDateRange)
074                    throws Exception {
075    
076                    if (checkDateRange &&
077                            !context.isWithinDateRange(fileEntry.getModifiedDate())) {
078    
079                            return;
080                    }
081    
082                    DLFileVersion fileVersion =
083                            DLFileVersionLocalServiceUtil.getFileVersion(
084                                    context.getScopeGroupId(), fileEntry.getFolderId(),
085                                    fileEntry.getName(), fileEntry.getVersion());
086    
087                    if (fileVersion.getStatus() != WorkflowConstants.STATUS_APPROVED) {
088                            return;
089                    }
090    
091                    if (foldersElement != null) {
092                            exportParentFolder(
093                                    context, foldersElement, fileEntry.getFolderId());
094                    }
095    
096                    String path = getFileEntryPath(context, fileEntry);
097    
098                    if (context.isPathNotProcessed(path)) {
099                            Element fileEntryElement = fileEntriesElement.addElement(
100                                    "file-entry");
101    
102                            fileEntryElement.addAttribute("path", path);
103    
104                            String binPath = getFileEntryBinPath(context, fileEntry);
105    
106                            fileEntryElement.addAttribute("bin-path", binPath);
107    
108                            fileEntry.setUserUuid(fileEntry.getUserUuid());
109    
110                            context.addLocks(
111                                    DLFileEntry.class,
112                                    DLUtil.getLockId(
113                                            fileEntry.getGroupId(), fileEntry.getFolderId(),
114                                            fileEntry.getName()));
115    
116                            context.addPermissions(
117                                    DLFileEntry.class, fileEntry.getFileEntryId());
118    
119                            if (context.getBooleanParameter(_NAMESPACE, "categories")) {
120                                    context.addAssetCategories(
121                                            DLFileEntry.class, fileEntry.getFileEntryId());
122                            }
123    
124                            if (context.getBooleanParameter(_NAMESPACE, "comments")) {
125                                    context.addComments(
126                                            DLFileEntry.class, fileEntry.getFileEntryId());
127                            }
128    
129                            if (context.getBooleanParameter(_NAMESPACE, "ratings")) {
130                                    context.addRatingsEntries(
131                                            DLFileEntry.class, fileEntry.getFileEntryId());
132                            }
133    
134                            if (context.getBooleanParameter(_NAMESPACE, "tags")) {
135                                    context.addAssetTags(
136                                            DLFileEntry.class, fileEntry.getFileEntryId());
137                            }
138    
139                            long repositoryId = getRepositoryId(
140                                    fileEntry.getGroupId(), fileEntry.getFolderId());
141    
142                            InputStream is = DLLocalServiceUtil.getFileAsStream(
143                                    fileEntry.getCompanyId(), repositoryId, fileEntry.getName(),
144                                    fileEntry.getVersion());
145    
146                            if (is == null) {
147                                    if (_log.isWarnEnabled()) {
148                                            _log.warn(
149                                                    "No file found for file entry " +
150                                                            fileEntry.getFileEntryId());
151                                    }
152    
153                                    fileEntryElement.detach();
154    
155                                    return;
156                            }
157    
158                            try {
159                                    context.addZipEntry(
160                                            getFileEntryBinPath(context, fileEntry), is);
161                            }
162                            finally {
163                                    try {
164                                            is.close();
165                                    }
166                                    catch (IOException ioe) {
167                                            _log.error(ioe, ioe);
168                                    }
169                            }
170    
171                            context.addZipEntry(path, fileEntry);
172    
173                            if (context.getBooleanParameter(_NAMESPACE, "ranks")) {
174                                    List<DLFileRank> fileRanks = DLFileRankUtil.findByF_N(
175                                            fileEntry.getFolderId(), fileEntry.getName());
176    
177                                    for (DLFileRank fileRank : fileRanks) {
178                                            exportFileRank(context, fileRanksElement, fileRank);
179                                    }
180                            }
181                    }
182            }
183    
184            public static String getFileEntryPath(
185                    PortletDataContext context, DLFileEntry fileEntry) {
186    
187                    StringBundler sb = new StringBundler(6);
188    
189                    sb.append(context.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
190                    sb.append("/file-entries/");
191                    sb.append(fileEntry.getFileEntryId());
192                    sb.append(StringPool.SLASH);
193                    sb.append(fileEntry.getVersion());
194                    sb.append(".xml");
195    
196                    return sb.toString();
197            }
198    
199            public static void importFileEntry(
200                            PortletDataContext context, Element fileEntryElement)
201                    throws Exception {
202    
203                    String path = fileEntryElement.attributeValue("path");
204    
205                    if (!context.isPathNotProcessed(path)) {
206                            return;
207                    }
208    
209                    DLFileEntry fileEntry = (DLFileEntry)context.getZipEntryAsObject(path);
210    
211                    String binPath = fileEntryElement.attributeValue("bin-path");
212    
213                    long userId = context.getUserId(fileEntry.getUserUuid());
214    
215                    Map<Long, Long> folderPKs =
216                            (Map<Long, Long>)context.getNewPrimaryKeysMap(DLFolder.class);
217    
218                    long folderId = MapUtil.getLong(
219                            folderPKs, fileEntry.getFolderId(), fileEntry.getFolderId());
220    
221                    long[] assetCategoryIds = null;
222                    String[] assetTagNames = null;
223    
224                    if (context.getBooleanParameter(_NAMESPACE, "categories")) {
225                            assetCategoryIds = context.getAssetCategoryIds(
226                                    DLFileEntry.class, fileEntry.getFileEntryId());
227                    }
228    
229                    if (context.getBooleanParameter(_NAMESPACE, "tags")) {
230                            assetTagNames = context.getAssetTagNames(
231                                    DLFileEntry.class, fileEntry.getFileEntryId());
232                    }
233    
234                    ServiceContext serviceContext = new ServiceContext();
235    
236                    serviceContext.setAddCommunityPermissions(true);
237                    serviceContext.setAddGuestPermissions(true);
238                    serviceContext.setAssetCategoryIds(assetCategoryIds);
239                    serviceContext.setAssetTagNames(assetTagNames);
240                    serviceContext.setCreateDate(fileEntry.getCreateDate());
241                    serviceContext.setModifiedDate(fileEntry.getModifiedDate());
242                    serviceContext.setScopeGroupId(context.getScopeGroupId());
243    
244                    InputStream is = context.getZipEntryAsInputStream(binPath);
245    
246                    if ((folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
247                            (folderId == fileEntry.getFolderId())) {
248    
249                            String folderPath = getImportFolderPath(context, folderId);
250    
251                            DLFolder folder = (DLFolder)context.getZipEntryAsObject(folderPath);
252    
253                            importFolder(context, folder);
254    
255                            folderId = MapUtil.getLong(
256                                    folderPKs, fileEntry.getFolderId(), fileEntry.getFolderId());
257                    }
258    
259                    DLFileEntry importedFileEntry = null;
260    
261                    String nameWithExtension =
262                            fileEntry.getName().concat(StringPool.PERIOD).concat(
263                                    fileEntry.getExtension());
264    
265                    if (context.isDataStrategyMirror()) {
266                            DLFileEntry existingFileEntry = DLFileEntryUtil.fetchByUUID_G(
267                                    fileEntry.getUuid(), context.getScopeGroupId());
268    
269                            if (existingFileEntry == null) {
270                                    serviceContext.setUuid(fileEntry.getUuid());
271    
272                                    importedFileEntry =
273                                            DLFileEntryLocalServiceUtil.addFileEntry(
274                                                    userId, context.getScopeGroupId(), folderId,
275                                                    nameWithExtension, fileEntry.getTitle(),
276                                                    fileEntry.getDescription(), null,
277                                                    fileEntry.getExtraSettings(), is, fileEntry.getSize(),
278                                                    serviceContext);
279                            }
280                            else if (!isDuplicateFileEntry(fileEntry, existingFileEntry)) {
281                                    importedFileEntry = DLFileEntryLocalServiceUtil.updateFileEntry(
282                                            userId, context.getScopeGroupId(),
283                                            existingFileEntry.getFolderId(),
284                                            existingFileEntry.getName(), fileEntry.getTitle(),
285                                            fileEntry.getTitle(), fileEntry.getDescription(), null,
286                                            true, fileEntry.getExtraSettings(), is, fileEntry.getSize(),
287                                            serviceContext);
288                            }
289                            else {
290                                    DLFileVersion latestFileVersion =
291                                            DLFileVersionLocalServiceUtil.getLatestFileVersion(
292                                                    context.getScopeGroupId(), folderId,
293                                                    existingFileEntry.getName());
294    
295                                    DLFileEntryLocalServiceUtil.updateAsset(
296                                            userId, existingFileEntry, latestFileVersion,
297                                            assetCategoryIds, assetTagNames);
298    
299                                    Indexer indexer = IndexerRegistryUtil.getIndexer(
300                                            DLFileEntry.class);
301    
302                                    indexer.reindex(existingFileEntry);
303    
304                                    importedFileEntry = existingFileEntry;
305                            }
306                    }
307                    else {
308                            String title = fileEntry.getTitle();
309    
310                            try {
311                                    importedFileEntry =
312                                            DLFileEntryLocalServiceUtil.addFileEntry(
313                                                    userId, context.getScopeGroupId(), folderId,
314                                                    nameWithExtension, title, fileEntry.getDescription(),
315                                                    null, fileEntry.getExtraSettings(), is,
316                                                    fileEntry.getSize(), serviceContext);
317                            }
318                            catch (DuplicateFileException dfe) {
319                                    String[] titleParts = title.split("\\.", 2);
320    
321                                    title = titleParts[0] + PwdGenerator.getPassword();
322    
323                                    if (titleParts.length > 1) {
324                                            title += StringPool.PERIOD + titleParts[1];
325                                    }
326    
327                                    importedFileEntry =
328                                            DLFileEntryLocalServiceUtil.addFileEntry(
329                                                    userId, context.getScopeGroupId(), folderId,
330                                                    nameWithExtension, title, fileEntry.getDescription(),
331                                                    null, fileEntry.getExtraSettings(), is,
332                                                    fileEntry.getSize(), serviceContext);
333                            }
334                    }
335    
336                    Map<Long, Long> fileEntryPKs =
337                            (Map<Long, Long>)context.getNewPrimaryKeysMap(DLFileEntry.class);
338    
339                    fileEntryPKs.put(
340                            fileEntry.getFileEntryId(), importedFileEntry.getFileEntryId());
341    
342                    Map<String, String> fileEntryNames =
343                            (Map<String, String>)context.getNewPrimaryKeysMap(
344                                    DLFileEntry.class.getName() + ".name");
345    
346                    fileEntryNames.put(fileEntry.getName(), importedFileEntry.getName());
347    
348                    String lockKey = DLUtil.getLockId(
349                            fileEntry.getGroupId(), fileEntry.getFolderId(),
350                            fileEntry.getName());
351    
352                    String newLockKey = DLUtil.getLockId(
353                            importedFileEntry.getGroupId(), importedFileEntry.getFolderId(),
354                            importedFileEntry.getName());
355    
356                    context.importLocks(DLFileEntry.class, lockKey, newLockKey);
357    
358                    context.importPermissions(
359                            DLFileEntry.class, fileEntry.getFileEntryId(),
360                            importedFileEntry.getFileEntryId());
361    
362                    if (context.getBooleanParameter(_NAMESPACE, "comments")) {
363                            context.importComments(
364                                    DLFileEntry.class, fileEntry.getFileEntryId(),
365                                    importedFileEntry.getFileEntryId(), context.getScopeGroupId());
366                    }
367    
368                    if (context.getBooleanParameter(_NAMESPACE, "ratings")) {
369                            context.importRatingsEntries(
370                                    DLFileEntry.class, fileEntry.getFileEntryId(),
371                                    importedFileEntry.getFileEntryId());
372                    }
373            }
374    
375            public static void importFileRank(
376                            PortletDataContext context, Element fileRankElement)
377                    throws Exception {
378    
379                    String path = fileRankElement.attributeValue("path");
380    
381                    if (!context.isPathNotProcessed(path)) {
382                            return;
383                    }
384    
385                    DLFileRank fileRank =
386                            (DLFileRank)context.getZipEntryAsObject(path);
387    
388                    importFileRank(context, fileRank);
389            }
390    
391            public static void importFolder(
392                            PortletDataContext context, Element folderElement)
393                    throws Exception {
394    
395                    String path = folderElement.attributeValue("path");
396    
397                    if (!context.isPathNotProcessed(path)) {
398                            return;
399                    }
400    
401                    DLFolder folder = (DLFolder)context.getZipEntryAsObject(path);
402    
403                    importFolder(context, folder);
404            }
405    
406            public PortletDataHandlerControl[] getExportControls() {
407                    return new PortletDataHandlerControl[] {
408                            _foldersAndDocuments, _shortcuts, _ranks, _categories, _comments,
409                            _ratings, _tags
410                    };
411            }
412    
413            public PortletDataHandlerControl[] getImportControls() {
414                    return new PortletDataHandlerControl[] {
415                            _foldersAndDocuments, _shortcuts, _ranks, _categories, _comments,
416                            _ratings, _tags
417                    };
418            }
419    
420            public boolean isAlwaysExportable() {
421                    return _ALWAYS_EXPORTABLE;
422            }
423    
424            public boolean isPublishToLiveByDefault() {
425                    return PropsValues.DL_PUBLISH_TO_LIVE_BY_DEFAULT;
426            }
427    
428            protected static void exportFileRank(
429                            PortletDataContext context, Element fileRanksElement,
430                            DLFileRank fileRank)
431                    throws Exception {
432    
433                    String path = getFileRankPath(context, fileRank);
434    
435                    if (!context.isPathNotProcessed(path)) {
436                            return;
437                    }
438    
439                    Element fileRankElement = fileRanksElement.addElement("file-rank");
440    
441                    fileRankElement.addAttribute("path", path);
442    
443                    fileRank.setUserUuid(fileRank.getUserUuid());
444    
445                    context.addZipEntry(path, fileRank);
446            }
447    
448            protected static void exportFileShortcut(
449                            PortletDataContext context, Element foldersElement,
450                            Element fileShortcutsElement, DLFileShortcut fileShortcut)
451                    throws Exception {
452    
453                    exportParentFolder(context, foldersElement, fileShortcut.getFolderId());
454    
455                    String path = getFileShortcutPath(context, fileShortcut);
456    
457                    if (context.isPathNotProcessed(path)) {
458                            Element fileShortcutElement = fileShortcutsElement.addElement(
459                                    "file-shortcut");
460    
461                            fileShortcutElement.addAttribute("path", path);
462    
463                            fileShortcut.setUserUuid(fileShortcut.getUserUuid());
464    
465                            context.addPermissions(
466                                    DLFileShortcut.class, fileShortcut.getFileShortcutId());
467    
468                            context.addZipEntry(path, fileShortcut);
469                    }
470            }
471    
472            protected static void exportFolder(
473                            PortletDataContext context, Element foldersElement,
474                            Element fileEntriesElement, Element fileShortcutsElement,
475                            Element fileRanksElement, DLFolder folder)
476                    throws Exception {
477    
478                    if (context.isWithinDateRange(folder.getModifiedDate())) {
479                            exportParentFolder(
480                                    context, foldersElement, folder.getParentFolderId());
481    
482                            String path = getFolderPath(context, folder);
483    
484                            if (context.isPathNotProcessed(path)) {
485                                    Element folderElement = foldersElement.addElement("folder");
486    
487                                    folderElement.addAttribute("path", path);
488    
489                                    folder.setUserUuid(folder.getUserUuid());
490    
491                                    context.addPermissions(DLFolder.class, folder.getFolderId());
492    
493                                    context.addZipEntry(path, folder);
494                            }
495                    }
496    
497                    List<DLFileEntry> fileEntries = DLFileEntryUtil.findByG_F(
498                            folder.getGroupId(), folder.getFolderId());
499    
500                    for (DLFileEntry fileEntry : fileEntries) {
501                            exportFileEntry(
502                                    context, foldersElement, fileEntriesElement, fileRanksElement,
503                                    fileEntry, true);
504                    }
505    
506                    if (context.getBooleanParameter(_NAMESPACE, "shortcuts")) {
507                            List<DLFileShortcut> fileShortcuts = DLFileShortcutUtil.findByG_F(
508                                    folder.getGroupId(), folder.getFolderId());
509    
510                            for (DLFileShortcut fileShortcut : fileShortcuts) {
511                                    exportFileShortcut(
512                                            context, foldersElement, fileShortcutsElement,
513                                            fileShortcut);
514                            }
515                    }
516            }
517    
518            protected static void exportParentFolder(
519                            PortletDataContext context, Element foldersElement, long folderId)
520                    throws Exception {
521    
522                    if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
523                            return;
524                    }
525    
526                    DLFolder folder = DLFolderUtil.findByPrimaryKey(folderId);
527    
528                    exportParentFolder(context, foldersElement, folder.getParentFolderId());
529    
530                    String path = getFolderPath(context, folder);
531    
532                    if (context.isPathNotProcessed(path)) {
533                            Element folderElement = foldersElement.addElement("folder");
534    
535                            folderElement.addAttribute("path", path);
536    
537                            folder.setUserUuid(folder.getUserUuid());
538    
539                            context.addPermissions(DLFolder.class, folder.getFolderId());
540    
541                            context.addZipEntry(path, folder);
542                    }
543            }
544    
545            protected static String getFileEntryBinPath(
546                    PortletDataContext context, DLFileEntry fileEntry) {
547    
548                    StringBundler sb = new StringBundler(5);
549    
550                    sb.append(context.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
551                    sb.append("/bin/");
552                    sb.append(fileEntry.getFileEntryId());
553                    sb.append(StringPool.SLASH);
554                    sb.append(fileEntry.getVersion());
555    
556                    return sb.toString();
557            }
558    
559            protected static String getFileRankPath(
560                    PortletDataContext context, DLFileRank fileRank) {
561    
562                    StringBundler sb = new StringBundler(4);
563    
564                    sb.append(context.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
565                    sb.append("/ranks/");
566                    sb.append(fileRank.getFileRankId());
567                    sb.append(".xml");
568    
569                    return sb.toString();
570            }
571    
572            protected static String getFileShortcutPath(
573                    PortletDataContext context, DLFileShortcut fileShortcut) {
574    
575                    StringBundler sb = new StringBundler(4);
576    
577                    sb.append(context.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
578                    sb.append("/shortcuts/");
579                    sb.append(fileShortcut.getFileShortcutId());
580                    sb.append(".xml");
581    
582                    return sb.toString();
583            }
584    
585            protected static String getFolderName(
586                            long companyId, long groupId, long parentFolderId, String name,
587                            int count)
588                    throws Exception {
589    
590                    DLFolder folder = DLFolderUtil.fetchByG_P_N(
591                            groupId, parentFolderId, name);
592    
593                    if (folder == null) {
594                            return name;
595                    }
596    
597                    if (Pattern.matches(".* \\(\\d+\\)", name)) {
598                            int pos = name.lastIndexOf(" (");
599    
600                            name = name.substring(0, pos);
601                    }
602    
603                    StringBundler sb = new StringBundler(5);
604    
605                    sb.append(name);
606                    sb.append(StringPool.SPACE);
607                    sb.append(StringPool.OPEN_PARENTHESIS);
608                    sb.append(count);
609                    sb.append(StringPool.CLOSE_PARENTHESIS);
610    
611                    name = sb.toString();
612    
613                    return getFolderName(companyId, groupId, parentFolderId, name, ++count);
614            }
615    
616            protected static String getFolderPath(
617                    PortletDataContext context, DLFolder folder) {
618    
619                    StringBundler sb = new StringBundler(4);
620    
621                    sb.append(context.getPortletPath(PortletKeys.DOCUMENT_LIBRARY));
622                    sb.append("/folders/");
623                    sb.append(folder.getFolderId());
624                    sb.append(".xml");
625    
626                    return sb.toString();
627            }
628    
629            protected static String getImportFolderPath(
630                    PortletDataContext context, long folderId) {
631    
632                    StringBundler sb = new StringBundler(4);
633    
634                    sb.append(context.getSourcePortletPath(PortletKeys.DOCUMENT_LIBRARY));
635                    sb.append("/folders/");
636                    sb.append(folderId);
637                    sb.append(".xml");
638    
639                    return sb.toString();
640            }
641    
642            protected static long getRepositoryId(long groupId, long folderId) {
643                    if (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
644                            return groupId;
645                    }
646                    else {
647                            return folderId;
648                    }
649            }
650    
651            protected static void importFileRank(
652                            PortletDataContext context, DLFileRank rank)
653                    throws Exception {
654    
655                    long userId = context.getUserId(rank.getUserUuid());
656    
657                    Map<Long, Long> folderPKs =
658                            (Map<Long, Long>)context.getNewPrimaryKeysMap(
659                                    DLFolder.class);
660    
661                    long folderId = MapUtil.getLong(
662                            folderPKs, rank.getFolderId(), rank.getFolderId());
663    
664                    Map<String, String> fileEntryNames =
665                            (Map<String, String>)context.getNewPrimaryKeysMap(
666                                    DLFileEntry.class.getName() + ".name");
667    
668                    String name = fileEntryNames.get(rank.getName());
669    
670                    if (name == null) {
671                            name = rank.getName();
672                    }
673    
674                    ServiceContext serviceContext = new ServiceContext();
675    
676                    serviceContext.setCreateDate(rank.getCreateDate());
677    
678                    if ((folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
679                            (folderId == rank.getFolderId())) {
680    
681                            String path = getImportFolderPath(context, folderId);
682    
683                            DLFolder folder = (DLFolder)context.getZipEntryAsObject(path);
684    
685                            importFolder(context, folder);
686    
687                            folderId = MapUtil.getLong(
688                                    folderPKs, rank.getFolderId(), rank.getFolderId());
689                    }
690    
691                    DLFileRankLocalServiceUtil.updateFileRank(
692                            context.getScopeGroupId(), context.getCompanyId(), userId, folderId,
693                            name, serviceContext);
694            }
695    
696            protected static void importFileShortcut(
697                            PortletDataContext context, DLFileShortcut fileShortcut)
698                    throws Exception {
699    
700                    long userId = context.getUserId(fileShortcut.getUserUuid());
701    
702                    Map<Long, Long> folderPKs =
703                            (Map<Long, Long>)context.getNewPrimaryKeysMap(DLFolder.class);
704    
705                    long folderId = MapUtil.getLong(
706                            folderPKs, fileShortcut.getFolderId(), fileShortcut.getFolderId());
707                    long toFolderId = MapUtil.getLong(
708                            folderPKs, fileShortcut.getToFolderId(),
709                            fileShortcut.getToFolderId());
710    
711                    Map<String, String> fileEntryNames =
712                            (Map<String, String>)context.getNewPrimaryKeysMap(
713                                    DLFileEntry.class.getName() + ".name");
714    
715                    String toName = MapUtil.getString(
716                            fileEntryNames, fileShortcut.getToName(), fileShortcut.getToName());
717    
718                    DLFolder folder = DLFolderUtil.findByPrimaryKey(folderId);
719    
720                    DLFileEntry fileEntry = DLFileEntryLocalServiceUtil.getFileEntry(
721                            folder.getGroupId(), toFolderId, toName);
722    
723                    long[] assetCategoryIds = null;
724                    String[] assetTagNames = null;
725    
726                    if (context.getBooleanParameter(_NAMESPACE, "categories")) {
727                            assetCategoryIds = context.getAssetCategoryIds(
728                                    DLFileEntry.class, fileEntry.getFileEntryId());
729                    }
730    
731                    if (context.getBooleanParameter(_NAMESPACE, "tags")) {
732                            assetTagNames = context.getAssetTagNames(
733                                    DLFileEntry.class, fileEntry.getFileEntryId());
734                    }
735    
736                    ServiceContext serviceContext = new ServiceContext();
737    
738                    serviceContext.setAddCommunityPermissions(true);
739                    serviceContext.setAddGuestPermissions(true);
740                    serviceContext.setAssetCategoryIds(assetCategoryIds);
741                    serviceContext.setAssetTagNames(assetTagNames);
742                    serviceContext.setCreateDate(fileShortcut.getCreateDate());
743                    serviceContext.setModifiedDate(fileShortcut.getModifiedDate());
744                    serviceContext.setScopeGroupId(context.getScopeGroupId());
745    
746                    DLFileShortcut importedFileShortcut = null;
747    
748                    if (context.isDataStrategyMirror()) {
749                            DLFileShortcut existingFileShortcut =
750                                    DLFileShortcutUtil.fetchByUUID_G(
751                                            fileShortcut.getUuid(), context.getScopeGroupId());
752    
753                            if (existingFileShortcut == null) {
754                                    serviceContext.setUuid(fileShortcut.getUuid());
755    
756                                    importedFileShortcut =
757                                            DLFileShortcutLocalServiceUtil.addFileShortcut(
758                                                    userId, folder.getGroupId(), folderId, toFolderId,
759                                                    toName, serviceContext);
760                            }
761                            else {
762                                    importedFileShortcut =
763                                            DLFileShortcutLocalServiceUtil.updateFileShortcut(
764                                                    userId, existingFileShortcut.getFileShortcutId(),
765                                                    folderId, toFolderId, toName, serviceContext);
766                            }
767                    }
768                    else {
769                            importedFileShortcut =
770                                    DLFileShortcutLocalServiceUtil.addFileShortcut(
771                                            userId, folder.getGroupId(), folderId, toFolderId, toName,
772                                            serviceContext);
773                    }
774    
775                    context.importPermissions(
776                            DLFileShortcut.class, fileShortcut.getPrimaryKey(),
777                            importedFileShortcut.getPrimaryKey());
778            }
779    
780            protected static void importFileShortcut(
781                            PortletDataContext context, Element fileShortcutElement)
782                    throws Exception {
783    
784                    String path = fileShortcutElement.attributeValue("path");
785    
786                    if (!context.isPathNotProcessed(path)) {
787                            return;
788                    }
789    
790                    DLFileShortcut fileShortcut =
791                            (DLFileShortcut)context.getZipEntryAsObject(path);
792    
793                    importFileShortcut(context, fileShortcut);
794            }
795    
796            protected static void importFolder(
797                            PortletDataContext context, DLFolder folder)
798                    throws Exception {
799    
800                    long userId = context.getUserId(folder.getUserUuid());
801    
802                    Map<Long, Long> folderPKs =
803                            (Map<Long, Long>)context.getNewPrimaryKeysMap(DLFolder.class);
804    
805                    long parentFolderId = MapUtil.getLong(
806                            folderPKs, folder.getParentFolderId(), folder.getParentFolderId());
807    
808                    ServiceContext serviceContext = new ServiceContext();
809    
810                    serviceContext.setAddCommunityPermissions(true);
811                    serviceContext.setAddGuestPermissions(true);
812                    serviceContext.setCreateDate(folder.getCreateDate());
813                    serviceContext.setModifiedDate(folder.getModifiedDate());
814    
815                    if ((parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) &&
816                            (parentFolderId == folder.getParentFolderId())) {
817    
818                            String path = getImportFolderPath(context, parentFolderId);
819    
820                            DLFolder parentFolder = (DLFolder)context.getZipEntryAsObject(path);
821    
822                            importFolder(context, parentFolder);
823    
824                            parentFolderId = MapUtil.getLong(
825                                    folderPKs, folder.getParentFolderId(),
826                                    folder.getParentFolderId());
827                    }
828    
829                    DLFolder importedFolder = null;
830    
831                    if (context.isDataStrategyMirror()) {
832                            DLFolder existingFolder = DLFolderUtil.fetchByUUID_G(
833                                    folder.getUuid(), context.getScopeGroupId());
834    
835                            if (existingFolder == null) {
836                                    String name = getFolderName(
837                                            context.getCompanyId(), context.getScopeGroupId(),
838                                            parentFolderId, folder.getName(), 2);
839    
840                                    serviceContext.setUuid(folder.getUuid());
841    
842                                    importedFolder = DLFolderLocalServiceUtil.addFolder(
843                                            userId, context.getScopeGroupId(), parentFolderId, name,
844                                            folder.getDescription(), serviceContext);
845                            }
846                            else {
847                                    importedFolder = DLFolderLocalServiceUtil.updateFolder(
848                                            existingFolder.getFolderId(), parentFolderId,
849                                            folder.getName(), folder.getDescription(), serviceContext);
850                            }
851                    }
852                    else {
853                            String name = getFolderName(
854                                    context.getCompanyId(), context.getScopeGroupId(),
855                                    parentFolderId, folder.getName(), 2);
856    
857                            importedFolder = DLFolderLocalServiceUtil.addFolder(
858                                    userId, context.getScopeGroupId(), parentFolderId, name,
859                                    folder.getDescription(), serviceContext);
860                    }
861    
862                    folderPKs.put(folder.getFolderId(), importedFolder.getFolderId());
863    
864                    context.importPermissions(
865                            DLFolder.class, folder.getFolderId(), importedFolder.getFolderId());
866            }
867    
868            protected static boolean isDuplicateFileEntry(
869                    DLFileEntry fileEntry1, DLFileEntry fileEntry2) {
870    
871                    try {
872                            DLFolder folder1 = fileEntry1.getFolder();
873                            DLFolder folder2 = fileEntry2.getFolder();
874    
875                            if ((folder1.getUuid().equals(folder2.getUuid())) &&
876                                    (fileEntry1.getSize() == fileEntry2.getSize()) &&
877                                    (DLUtil.compareVersions(
878                                            fileEntry1.getVersion(), fileEntry2.getVersion()) == 0) &&
879                                    (fileEntry1.getVersionUserUuid().equals(
880                                            fileEntry2.getVersionUserUuid()))) {
881    
882                                    return true;
883                            }
884                            else {
885                                    return false;
886                            }
887                    }
888                    catch (Exception e) {
889                            return false;
890                    }
891            }
892    
893            protected PortletPreferences doDeleteData(
894                            PortletDataContext context, String portletId,
895                            PortletPreferences preferences)
896                    throws Exception {
897    
898                    if (!context.addPrimaryKey(
899                                    DLPortletDataHandlerImpl.class, "deleteData")) {
900    
901                            DLFolderLocalServiceUtil.deleteFolders(context.getScopeGroupId());
902    
903                            DLFileEntryLocalServiceUtil.deleteFileEntries(
904                                    context.getScopeGroupId(),
905                                    DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
906                    }
907    
908                    return null;
909            }
910    
911            protected String doExportData(
912                            PortletDataContext context, String portletId,
913                            PortletPreferences preferences)
914                    throws Exception {
915    
916                    context.addPermissions(
917                            "com.liferay.portlet.documentlibrary", context.getScopeGroupId());
918    
919                    Document document = SAXReaderUtil.createDocument();
920    
921                    Element rootElement = document.addElement("documentlibrary-data");
922    
923                    rootElement.addAttribute(
924                            "group-id", String.valueOf(context.getScopeGroupId()));
925    
926                    Element foldersElement = rootElement.addElement("folders");
927                    Element fileEntriesElement = rootElement.addElement("file-entries");
928                    Element fileShortcutsElement = rootElement.addElement("file-shortcuts");
929                    Element fileRanksElement = rootElement.addElement("file-ranks");
930    
931                    List<DLFolder> folders = DLFolderUtil.findByGroupId(
932                            context.getScopeGroupId());
933    
934                    for (DLFolder folder : folders) {
935                            exportFolder(
936                                    context, foldersElement, fileEntriesElement,
937                                    fileShortcutsElement, fileRanksElement, folder);
938                    }
939    
940                    List<DLFileEntry> fileEntries = DLFileEntryUtil.findByG_F(
941                            context.getScopeGroupId(),
942                            DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
943    
944                    for (DLFileEntry fileEntry : fileEntries) {
945                            exportFileEntry(
946                                    context, foldersElement, fileEntriesElement, fileRanksElement,
947                                    fileEntry, true);
948                    }
949    
950                    return document.formattedString();
951            }
952    
953            protected PortletPreferences doImportData(
954                            PortletDataContext context, String portletId,
955                            PortletPreferences preferences, String data)
956                    throws Exception {
957    
958                    context.importPermissions(
959                            "com.liferay.portlet.documentlibrary",
960                            context.getSourceGroupId(), context.getScopeGroupId());
961    
962                    Document document = SAXReaderUtil.read(data);
963    
964                    Element rootElement = document.getRootElement();
965    
966                    Element foldersElement = rootElement.element("folders");
967    
968                    List<Element> folderElements = foldersElement.elements("folder");
969    
970                    for (Element folderElement : folderElements) {
971                            importFolder(context, folderElement);
972                    }
973    
974                    Element fileEntriesElement = rootElement.element("file-entries");
975    
976                    List<Element> fileEntryElements = fileEntriesElement.elements(
977                            "file-entry");
978    
979                    for (Element fileEntryElement : fileEntryElements) {
980                            importFileEntry(context, fileEntryElement);
981                    }
982    
983                    if (context.getBooleanParameter(_NAMESPACE, "shortcuts")) {
984                            List<Element> fileShortcutElements = rootElement.element(
985                                    "file-shortcuts").elements("file-shortcut");
986    
987                            for (Element fileShortcutElement : fileShortcutElements) {
988                                    importFileShortcut(context, fileShortcutElement);
989                            }
990                    }
991    
992                    if (context.getBooleanParameter(_NAMESPACE, "ranks")) {
993                            Element fileRanksElement = rootElement.element("file-ranks");
994    
995                            List<Element> fileRankElements = fileRanksElement.elements(
996                                    "file-rank");
997    
998                            for (Element fileRankElement : fileRankElements) {
999                                    importFileRank(context, fileRankElement);
1000                            }
1001                    }
1002    
1003                    return null;
1004            }
1005    
1006            private static final boolean _ALWAYS_EXPORTABLE = true;
1007    
1008            private static final String _NAMESPACE = "document_library";
1009    
1010            private static Log _log = LogFactoryUtil.getLog(
1011                    DLPortletDataHandlerImpl.class);
1012    
1013            private static PortletDataHandlerBoolean _categories =
1014                    new PortletDataHandlerBoolean(_NAMESPACE, "categories");
1015    
1016            private static PortletDataHandlerBoolean _comments =
1017                    new PortletDataHandlerBoolean(_NAMESPACE, "comments");
1018    
1019            private static PortletDataHandlerBoolean _foldersAndDocuments =
1020                    new PortletDataHandlerBoolean(
1021                            _NAMESPACE, "folders-and-documents", true, true);
1022    
1023            private static PortletDataHandlerBoolean _ranks =
1024                    new PortletDataHandlerBoolean(_NAMESPACE, "ranks");
1025    
1026            private static PortletDataHandlerBoolean _ratings =
1027                    new PortletDataHandlerBoolean(_NAMESPACE, "ratings");
1028    
1029            private static PortletDataHandlerBoolean _shortcuts=
1030                    new PortletDataHandlerBoolean(_NAMESPACE, "shortcuts");
1031    
1032            private static PortletDataHandlerBoolean _tags =
1033                    new PortletDataHandlerBoolean(_NAMESPACE, "tags");
1034    
1035    }