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