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.lar;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.exception.SystemException;
019    import com.liferay.portal.kernel.lar.BaseStagedModelDataHandler;
020    import com.liferay.portal.kernel.lar.ExportImportPathUtil;
021    import com.liferay.portal.kernel.lar.PortletDataContext;
022    import com.liferay.portal.kernel.lar.StagedModelDataHandlerUtil;
023    import com.liferay.portal.kernel.repository.model.Folder;
024    import com.liferay.portal.kernel.trash.TrashHandler;
025    import com.liferay.portal.kernel.trash.TrashHandlerRegistryUtil;
026    import com.liferay.portal.kernel.util.GetterUtil;
027    import com.liferay.portal.kernel.util.MapUtil;
028    import com.liferay.portal.kernel.util.StringPool;
029    import com.liferay.portal.kernel.util.StringUtil;
030    import com.liferay.portal.kernel.util.Validator;
031    import com.liferay.portal.kernel.xml.Element;
032    import com.liferay.portal.repository.liferayrepository.model.LiferayFolder;
033    import com.liferay.portal.service.ServiceContext;
034    import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
035    import com.liferay.portlet.documentlibrary.model.DLFileEntryTypeConstants;
036    import com.liferay.portlet.documentlibrary.model.DLFolder;
037    import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
038    import com.liferay.portlet.documentlibrary.service.DLAppLocalServiceUtil;
039    import com.liferay.portlet.documentlibrary.service.DLFileEntryTypeLocalServiceUtil;
040    import com.liferay.portlet.documentlibrary.service.DLFolderLocalServiceUtil;
041    
042    import java.util.ArrayList;
043    import java.util.List;
044    import java.util.Map;
045    
046    /**
047     * @author Mate Thurzo
048     */
049    public class FolderStagedModelDataHandler
050            extends BaseStagedModelDataHandler<Folder> {
051    
052            public static final String[] CLASS_NAMES = {
053                    DLFolder.class.getName(), Folder.class.getName(),
054                    LiferayFolder.class.getName()
055            };
056    
057            @Override
058            public void deleteStagedModel(
059                            String uuid, long groupId, String className, String extraData)
060                    throws PortalException, SystemException {
061    
062                    DLFolder dlFolder =
063                            DLFolderLocalServiceUtil.fetchDLFolderByUuidAndGroupId(
064                                    uuid, groupId);
065    
066                    if (dlFolder != null) {
067                            DLFolderLocalServiceUtil.deleteFolder(dlFolder);
068                    }
069            }
070    
071            @Override
072            public String[] getClassNames() {
073                    return CLASS_NAMES;
074            }
075    
076            @Override
077            public String getDisplayName(Folder folder) {
078                    return folder.getName();
079            }
080    
081            @Override
082            protected void doExportStagedModel(
083                            PortletDataContext portletDataContext, Folder folder)
084                    throws Exception {
085    
086                    Element folderElement = portletDataContext.getExportDataElement(
087                            folder, Folder.class);
088    
089                    String folderPath = ExportImportPathUtil.getModelPath(folder);
090    
091                    if (folder.getParentFolderId() !=
092                                    DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
093    
094                            StagedModelDataHandlerUtil.exportReferenceStagedModel(
095                                    portletDataContext, folder, Folder.class,
096                                    folder.getParentFolder(), Folder.class,
097                                    PortletDataContext.REFERENCE_TYPE_PARENT);
098                    }
099    
100                    exportFolderFileEntryTypes(portletDataContext, folderElement, folder);
101    
102                    portletDataContext.addClassedModel(
103                            folderElement, folderPath, folder, DLFolder.class);
104            }
105    
106            @Override
107            protected void doImportCompanyStagedModel(
108                            PortletDataContext portletDataContext, Folder folder)
109                    throws Exception {
110    
111                    Folder existingFolder = FolderUtil.fetchByUUID_R(
112                            folder.getUuid(), portletDataContext.getCompanyGroupId());
113    
114                    Map<Long, Long> folderIds =
115                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
116                                    Folder.class);
117    
118                    folderIds.put(folder.getFolderId(), existingFolder.getFolderId());
119            }
120    
121            @Override
122            protected void doImportStagedModel(
123                            PortletDataContext portletDataContext, Folder folder)
124                    throws Exception {
125    
126                    long userId = portletDataContext.getUserId(folder.getUserUuid());
127    
128                    String path = ExportImportPathUtil.getModelPath(
129                            portletDataContext, Folder.class.getName(), folder.getFolderId());
130    
131                    Element folderElement = portletDataContext.getImportDataElement(
132                            Folder.class.getSimpleName(), "path", path);
133    
134                    if (folder.getParentFolderId() !=
135                                    DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
136    
137                            String parentFolderPath = ExportImportPathUtil.getModelPath(
138                                    portletDataContext, Folder.class.getName(),
139                                    folder.getParentFolderId());
140    
141                            Folder parentFolder =
142                                    (Folder)portletDataContext.getZipEntryAsObject(
143                                            parentFolderPath);
144    
145                            StagedModelDataHandlerUtil.importReferenceStagedModel(
146                                    portletDataContext, parentFolder);
147                    }
148    
149                    Map<Long, Long> folderIds =
150                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
151                                    Folder.class);
152    
153                    long parentFolderId = MapUtil.getLong(
154                            folderIds, folder.getParentFolderId(), folder.getParentFolderId());
155    
156                    ServiceContext serviceContext = portletDataContext.createServiceContext(
157                            folder, DLFolder.class);
158    
159                    serviceContext.setUserId(userId);
160    
161                    Folder importedFolder = null;
162    
163                    if (portletDataContext.isDataStrategyMirror()) {
164                            Folder existingFolder = FolderUtil.fetchByUUID_R(
165                                    folder.getUuid(), portletDataContext.getScopeGroupId());
166    
167                            if (existingFolder == null) {
168                                    String name = getFolderName(
169                                            null, portletDataContext.getScopeGroupId(), parentFolderId,
170                                            folder.getName(), 2);
171    
172                                    serviceContext.setUuid(folder.getUuid());
173    
174                                    importedFolder = DLAppLocalServiceUtil.addFolder(
175                                            userId, portletDataContext.getScopeGroupId(),
176                                            parentFolderId, name, folder.getDescription(),
177                                            serviceContext);
178                            }
179                            else {
180                                    String name = getFolderName(
181                                            folder.getUuid(), portletDataContext.getScopeGroupId(),
182                                            parentFolderId, folder.getName(), 2);
183    
184                                    importedFolder = DLAppLocalServiceUtil.updateFolder(
185                                            existingFolder.getFolderId(), parentFolderId, name,
186                                            folder.getDescription(), serviceContext);
187                            }
188                    }
189                    else {
190                            String name = getFolderName(
191                                    null, portletDataContext.getScopeGroupId(), parentFolderId,
192                                    folder.getName(), 2);
193    
194                            importedFolder = DLAppLocalServiceUtil.addFolder(
195                                    userId, portletDataContext.getScopeGroupId(), parentFolderId,
196                                    name, folder.getDescription(), serviceContext);
197                    }
198    
199                    importFolderFileEntryTypes(
200                            portletDataContext, folderElement, folder, serviceContext);
201    
202                    portletDataContext.importClassedModel(
203                            folder, importedFolder, DLFolder.class);
204    
205                    folderIds.put(folder.getFolderId(), importedFolder.getFolderId());
206            }
207    
208            @Override
209            protected void doRestoreStagedModel(
210                            PortletDataContext portletDataContext, Folder folder)
211                    throws Exception {
212    
213                    long userId = portletDataContext.getUserId(folder.getUserUuid());
214    
215                    Folder existingFolder = FolderUtil.fetchByUUID_R(
216                            folder.getUuid(), portletDataContext.getScopeGroupId());
217    
218                    if ((existingFolder == null) ||
219                            !(existingFolder.getModel() instanceof DLFolder)) {
220    
221                            return;
222                    }
223    
224                    DLFolder dlFolder = (DLFolder)existingFolder.getModel();
225    
226                    if (!dlFolder.isInTrash()) {
227                            return;
228                    }
229    
230                    TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
231                            DLFolder.class.getName());
232    
233                    if (trashHandler.isRestorable(existingFolder.getFolderId())) {
234                            trashHandler.restoreTrashEntry(
235                                    userId, existingFolder.getFolderId());
236                    }
237            }
238    
239            protected void exportFolderFileEntryTypes(
240                            PortletDataContext portletDataContext, Element folderElement,
241                            Folder folder)
242                    throws Exception {
243    
244                    List<DLFileEntryType> dlFileEntryTypes =
245                            DLFileEntryTypeLocalServiceUtil.getFolderFileEntryTypes(
246                                    new long[] {
247                                            portletDataContext.getCompanyGroupId(),
248                                            portletDataContext.getScopeGroupId()
249                                    },
250                                    folder.getFolderId(), false);
251    
252                    long defaultFileEntryTypeId =
253                            DLFileEntryTypeLocalServiceUtil.getDefaultFileEntryTypeId(
254                                    folder.getFolderId());
255    
256                    String defaultFileEntryTypeUuid = StringPool.BLANK;
257    
258                    for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
259                            if (dlFileEntryType.getFileEntryTypeId() ==
260                                            DLFileEntryTypeConstants.
261                                                    FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT) {
262    
263                                    folderElement.addAttribute("basic-document", "true");
264    
265                                    continue;
266                            }
267    
268                            if (defaultFileEntryTypeId ==
269                                            dlFileEntryType.getFileEntryTypeId()) {
270    
271                                    defaultFileEntryTypeUuid = dlFileEntryType.getUuid();
272                            }
273    
274                            if (dlFileEntryType.isExportable()) {
275                                    StagedModelDataHandlerUtil.exportReferenceStagedModel(
276                                            portletDataContext, folder, Folder.class, dlFileEntryType,
277                                            DLFileEntryType.class,
278                                            PortletDataContext.REFERENCE_TYPE_STRONG);
279                            }
280                    }
281    
282                    folderElement.addAttribute(
283                            "defaultFileEntryTypeUuid", defaultFileEntryTypeUuid);
284            }
285    
286            /**
287             * @see com.liferay.portal.lar.PortletImporter#getAssetCategoryName(String,
288             *      long, long, String, long, int)
289             * @see com.liferay.portal.lar.PortletImporter#getAssetVocabularyName(
290             *      String, long, String, int)
291             */
292            protected String getFolderName(
293                            String uuid, long groupId, long parentFolderId, String name,
294                            int count)
295                    throws Exception {
296    
297                    Folder folder = FolderUtil.fetchByR_P_N(groupId, parentFolderId, name);
298    
299                    if (folder == null) {
300                            return name;
301                    }
302    
303                    if (Validator.isNotNull(uuid) && uuid.equals(folder.getUuid())) {
304                            return name;
305                    }
306    
307                    name = StringUtil.appendParentheticalSuffix(name, count);
308    
309                    return getFolderName(uuid, groupId, parentFolderId, name, ++count);
310            }
311    
312            protected void importFolderFileEntryTypes(
313                            PortletDataContext portletDataContext, Element folderElement,
314                            Folder folder, ServiceContext serviceContext)
315                    throws Exception {
316    
317                    List<Long> currentFolderFileEntryTypeIds = new ArrayList<Long>();
318    
319                    String defaultFileEntryTypeUuid = GetterUtil.getString(
320                            folderElement.attributeValue("defaultFileEntryTypeUuid"));
321    
322                    long defaultFileEntryTypeId = 0;
323    
324                    List<Element> referenceDataElements =
325                            portletDataContext.getReferenceDataElements(
326                                    folderElement, DLFileEntryType.class);
327    
328                    for (Element referenceDataElement : referenceDataElements) {
329                            String referencePath = referenceDataElement.attributeValue("path");
330    
331                            DLFileEntryType referenceDLFileEntryType =
332                                    (DLFileEntryType)portletDataContext.getZipEntryAsObject(
333                                            referencePath);
334    
335                            StagedModelDataHandlerUtil.importReferenceStagedModel(
336                                    portletDataContext, referenceDLFileEntryType);
337    
338                            Map<Long, Long> fileEntryTypeIds =
339                                    (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
340                                            DLFileEntryType.class);
341    
342                            long dlFileEntryTypeId = MapUtil.getLong(
343                                    fileEntryTypeIds, referenceDLFileEntryType.getFileEntryTypeId(),
344                                    referenceDLFileEntryType.getFileEntryTypeId());
345    
346                            DLFileEntryType existingDLFileEntryType =
347                                    DLFileEntryTypeLocalServiceUtil.fetchDLFileEntryType(
348                                            dlFileEntryTypeId);
349    
350                            if (existingDLFileEntryType == null) {
351                                    continue;
352                            }
353    
354                            currentFolderFileEntryTypeIds.add(
355                                    existingDLFileEntryType.getFileEntryTypeId());
356    
357                            if (defaultFileEntryTypeUuid.equals(
358                                            referenceDLFileEntryType.getUuid())) {
359    
360                                    defaultFileEntryTypeId =
361                                            existingDLFileEntryType.getFileEntryTypeId();
362                            }
363                    }
364    
365                    if (GetterUtil.getBoolean(
366                                    folderElement.attributeValue("basic-document"))) {
367    
368                            currentFolderFileEntryTypeIds.add(
369                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_BASIC_DOCUMENT);
370                    }
371    
372                    if (!currentFolderFileEntryTypeIds.isEmpty()) {
373                            DLFolder dlFolder = (DLFolder)folder.getModel();
374    
375                            dlFolder.setDefaultFileEntryTypeId(defaultFileEntryTypeId);
376                            dlFolder.setOverrideFileEntryTypes(true);
377    
378                            DLFolderLocalServiceUtil.updateDLFolder(dlFolder);
379    
380                            DLFileEntryTypeLocalServiceUtil.updateFolderFileEntryTypes(
381                                    dlFolder, currentFolderFileEntryTypeIds, defaultFileEntryTypeId,
382                                    serviceContext);
383                    }
384            }
385    
386            @Override
387            protected boolean validateMissingReference(
388                            String uuid, long companyId, long groupId)
389                    throws Exception {
390    
391                    DLFolder dlFolder =
392                            DLFolderLocalServiceUtil.fetchDLFolderByUuidAndGroupId(
393                                    uuid, groupId);
394    
395                    if (dlFolder == null) {
396                            return false;
397                    }
398    
399                    return true;
400            }
401    
402    }