001    /**
002     * Copyright (c) 2000-present 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.portal.lar.test;
016    
017    import com.liferay.portal.kernel.comment.CommentManagerUtil;
018    import com.liferay.portal.kernel.test.rule.DeleteAfterTestRun;
019    import com.liferay.portal.kernel.test.util.GroupTestUtil;
020    import com.liferay.portal.kernel.test.util.RandomTestUtil;
021    import com.liferay.portal.kernel.test.util.ServiceContextTestUtil;
022    import com.liferay.portal.kernel.test.util.TestPropsValues;
023    import com.liferay.portal.kernel.util.DateUtil;
024    import com.liferay.portal.kernel.util.ListUtil;
025    import com.liferay.portal.kernel.util.Time;
026    import com.liferay.portal.kernel.workflow.WorkflowConstants;
027    import com.liferay.portal.kernel.xml.Document;
028    import com.liferay.portal.kernel.xml.Element;
029    import com.liferay.portal.kernel.xml.SAXReaderUtil;
030    import com.liferay.portal.kernel.zip.ZipReader;
031    import com.liferay.portal.kernel.zip.ZipReaderFactoryUtil;
032    import com.liferay.portal.kernel.zip.ZipWriter;
033    import com.liferay.portal.kernel.zip.ZipWriterFactoryUtil;
034    import com.liferay.portal.model.Company;
035    import com.liferay.portal.model.Group;
036    import com.liferay.portal.model.StagedGroupedModel;
037    import com.liferay.portal.model.StagedModel;
038    import com.liferay.portal.model.User;
039    import com.liferay.portal.service.CompanyLocalServiceUtil;
040    import com.liferay.portal.service.GroupLocalServiceUtil;
041    import com.liferay.portal.service.IdentityServiceContextFunction;
042    import com.liferay.portal.service.ServiceContext;
043    import com.liferay.portal.service.ServiceContextThreadLocal;
044    import com.liferay.portal.service.test.ServiceTestUtil;
045    import com.liferay.portlet.asset.model.AssetCategory;
046    import com.liferay.portlet.asset.model.AssetEntry;
047    import com.liferay.portlet.asset.model.AssetTag;
048    import com.liferay.portlet.asset.model.AssetVocabulary;
049    import com.liferay.portlet.asset.service.AssetCategoryLocalServiceUtil;
050    import com.liferay.portlet.asset.service.AssetEntryLocalServiceUtil;
051    import com.liferay.portlet.asset.service.AssetTagLocalServiceUtil;
052    import com.liferay.portlet.asset.service.AssetVocabularyLocalServiceUtil;
053    import com.liferay.portlet.asset.util.test.AssetTestUtil;
054    import com.liferay.portlet.exportimport.lar.ExportImportClassedModelUtil;
055    import com.liferay.portlet.exportimport.lar.ExportImportPathUtil;
056    import com.liferay.portlet.exportimport.lar.ExportImportThreadLocal;
057    import com.liferay.portlet.exportimport.lar.PortletDataContext;
058    import com.liferay.portlet.exportimport.lar.PortletDataContextFactoryUtil;
059    import com.liferay.portlet.exportimport.lar.PortletDataHandlerKeys;
060    import com.liferay.portlet.exportimport.lar.StagedModelDataHandler;
061    import com.liferay.portlet.exportimport.lar.StagedModelDataHandlerRegistryUtil;
062    import com.liferay.portlet.exportimport.lar.StagedModelDataHandlerUtil;
063    import com.liferay.portlet.exportimport.lar.UserIdStrategy;
064    import com.liferay.portlet.messageboards.model.MBMessage;
065    import com.liferay.portlet.messageboards.service.MBMessageLocalServiceUtil;
066    import com.liferay.portlet.ratings.model.RatingsEntry;
067    import com.liferay.portlet.ratings.service.RatingsEntryLocalServiceUtil;
068    import com.liferay.portlet.ratings.util.test.RatingsTestUtil;
069    
070    import java.io.Serializable;
071    
072    import java.util.ArrayList;
073    import java.util.Date;
074    import java.util.HashMap;
075    import java.util.Iterator;
076    import java.util.LinkedHashMap;
077    import java.util.List;
078    import java.util.Map;
079    
080    import org.junit.After;
081    import org.junit.Assert;
082    import org.junit.Before;
083    import org.junit.Test;
084    
085    /**
086     * @author Daniel Kocsis
087     * @author Mate Thurzo
088     */
089    public abstract class BaseStagedModelDataHandlerTestCase {
090    
091            @Before
092            public void setUp() throws Exception {
093                    liveGroup = GroupTestUtil.addGroup();
094                    stagingGroup = GroupTestUtil.addGroup();
095    
096                    ServiceTestUtil.setUser(TestPropsValues.getUser());
097    
098                    ServiceContext serviceContext =
099                            ServiceContextTestUtil.getServiceContext(stagingGroup.getGroupId());
100    
101                    ServiceContextThreadLocal.pushServiceContext(serviceContext);
102            }
103    
104            @After
105            public void tearDown() throws Exception {
106                    ServiceContextThreadLocal.popServiceContext();
107            }
108    
109            @Test
110            public void testCleanStagedModelDataHandler() throws Exception {
111    
112                    // Export
113    
114                    initExport();
115    
116                    Map<String, List<StagedModel>> dependentStagedModelsMap =
117                            addDependentStagedModelsMap(stagingGroup);
118    
119                    StagedModel stagedModel = addStagedModel(
120                            stagingGroup, dependentStagedModelsMap);
121    
122                    // Comments
123    
124                    addComments(stagedModel);
125    
126                    // Ratings
127    
128                    addRatings(stagedModel);
129    
130                    StagedModelDataHandlerUtil.exportStagedModel(
131                            portletDataContext, stagedModel);
132    
133                    validateExport(
134                            portletDataContext, stagedModel, dependentStagedModelsMap);
135    
136                    // Import
137    
138                    initImport();
139    
140                    deleteStagedModel(stagedModel, dependentStagedModelsMap, stagingGroup);
141    
142                    // Reread the staged model for import from ZIP for true testing
143    
144                    StagedModel exportedStagedModel = readExportedStagedModel(stagedModel);
145    
146                    Assert.assertNotNull(exportedStagedModel);
147    
148                    StagedModelDataHandlerUtil.importStagedModel(
149                            portletDataContext, exportedStagedModel);
150            }
151    
152            public void testLastPublishDate() throws Exception {
153                    if (!supportLastPublishDateUpdate()) {
154                            return;
155                    }
156    
157                    Map<String, List<StagedModel>> dependentStagedModelsMap =
158                            new HashMap<>();
159    
160                    StagedGroupedModel stagedGroupedModel =
161                            (StagedGroupedModel)addStagedModel(
162                                    stagingGroup, dependentStagedModelsMap);
163    
164                    Assert.assertNull(stagedGroupedModel.getLastPublishDate());
165    
166                    initExport();
167    
168                    // Update last publish date
169    
170                    Map<String, String[]> parameterMap =
171                            portletDataContext.getParameterMap();
172    
173                    parameterMap.put(
174                            PortletDataHandlerKeys.UPDATE_LAST_PUBLISH_DATE,
175                            new String[] {Boolean.TRUE.toString()});
176    
177                    try {
178                            ExportImportThreadLocal.setPortletStagingInProcess(true);
179    
180                            StagedModelDataHandlerUtil.exportStagedModel(
181                                    portletDataContext, stagedGroupedModel);
182                    }
183                    finally {
184                            ExportImportThreadLocal.setPortletStagingInProcess(false);
185                    }
186    
187                    Assert.assertEquals(
188                            portletDataContext.getEndDate(),
189                            stagedGroupedModel.getLastPublishDate());
190    
191                    // Do not update last publish date
192    
193                    Date originalLastPublishDate = stagedGroupedModel.getLastPublishDate();
194    
195                    parameterMap.put(
196                            PortletDataHandlerKeys.UPDATE_LAST_PUBLISH_DATE,
197                            new String[] {Boolean.TRUE.toString()});
198    
199                    try {
200                            ExportImportThreadLocal.setPortletStagingInProcess(true);
201    
202                            StagedModelDataHandlerUtil.exportStagedModel(
203                                    portletDataContext, stagedGroupedModel);
204                    }
205                    finally {
206                            ExportImportThreadLocal.setPortletStagingInProcess(false);
207                    }
208    
209                    Assert.assertEquals(
210                            originalLastPublishDate, stagedGroupedModel.getLastPublishDate());
211            }
212    
213            @Test
214            public void testStagedModelDataHandler() throws Exception {
215    
216                    // Export
217    
218                    initExport();
219    
220                    Map<String, List<StagedModel>> dependentStagedModelsMap =
221                            addDependentStagedModelsMap(stagingGroup);
222    
223                    StagedModel stagedModel = addStagedModel(
224                            stagingGroup, dependentStagedModelsMap);
225    
226                    // Assets
227    
228                    StagedModelAssets stagedModelAssets = updateAssetEntry(
229                            stagedModel, stagingGroup);
230    
231                    // Comments
232    
233                    addComments(stagedModel);
234    
235                    // Ratings
236    
237                    addRatings(stagedModel);
238    
239                    StagedModelDataHandlerUtil.exportStagedModel(
240                            portletDataContext, stagedModel);
241    
242                    validateExport(
243                            portletDataContext, stagedModel, dependentStagedModelsMap);
244    
245                    // Import
246    
247                    initImport();
248    
249                    // Reread the staged model for import from ZIP for true testing
250    
251                    StagedModel exportedStagedModel = readExportedStagedModel(stagedModel);
252    
253                    Assert.assertNotNull(exportedStagedModel);
254    
255                    StagedModelDataHandlerUtil.importStagedModel(
256                            portletDataContext, exportedStagedModel);
257    
258                    validateImport(
259                            stagedModel, stagedModelAssets, dependentStagedModelsMap,
260                            liveGroup);
261            }
262    
263            @Test
264            public void testVersioning() throws Exception {
265                    if (!isVersionableStagedModel()) {
266                            return;
267                    }
268    
269                    Map<String, List<StagedModel>> dependentStagedModelsMap =
270                            addDependentStagedModelsMap(stagingGroup);
271    
272                    StagedModel stagedModel = addStagedModel(
273                            stagingGroup, dependentStagedModelsMap);
274    
275                    stagedModel = addVersion(stagedModel);
276    
277                    exportImportStagedModel(stagedModel);
278    
279                    StagedModel importedStagedModel = getStagedModel(
280                            stagedModel.getUuid(), liveGroup);
281    
282                    Assert.assertNotNull(importedStagedModel);
283    
284                    validateImportedStagedModel(stagedModel, importedStagedModel);
285            }
286    
287            @Test
288            public void testVersioning2() throws Exception {
289                    if (!isVersionableStagedModel()) {
290                            return;
291                    }
292    
293                    Map<String, List<StagedModel>> dependentStagedModelsMap =
294                            addDependentStagedModelsMap(stagingGroup);
295    
296                    StagedModel stagedModel = addStagedModel(
297                            stagingGroup, dependentStagedModelsMap);
298    
299                    // Make sure the dates are different
300    
301                    Thread.sleep(4000);
302    
303                    exportImportStagedModel(stagedModel);
304    
305                    StagedModel importedStagedModel = getStagedModel(
306                            stagedModel.getUuid(), liveGroup);
307    
308                    validateImportedStagedModel(stagedModel, importedStagedModel);
309    
310                    stagedModel = addVersion(stagedModel);
311    
312                    exportImportStagedModel(stagedModel);
313    
314                    importedStagedModel = getStagedModel(stagedModel.getUuid(), liveGroup);
315    
316                    validateImportedStagedModel(stagedModel, importedStagedModel);
317            }
318    
319            @Test
320            public void testVersioningExportImportTwice() throws Exception {
321                    if (!isVersionableStagedModel()) {
322                            return;
323                    }
324    
325                    Map<String, List<StagedModel>> dependentStagedModelsMap =
326                            addDependentStagedModelsMap(stagingGroup);
327    
328                    StagedModel stagedModel = addStagedModel(
329                            stagingGroup, dependentStagedModelsMap);
330    
331                    stagedModel = addVersion(stagedModel);
332    
333                    exportImportStagedModel(stagedModel);
334    
335                    StagedModel importedStagedModel = getStagedModel(
336                            stagedModel.getUuid(), liveGroup);
337    
338                    Assert.assertNotNull(importedStagedModel);
339    
340                    validateImportedStagedModel(stagedModel, importedStagedModel);
341    
342                    exportImportStagedModel(stagedModel);
343    
344                    importedStagedModel = getStagedModel(stagedModel.getUuid(), liveGroup);
345    
346                    Assert.assertNotNull(importedStagedModel);
347    
348                    validateImportedStagedModel(stagedModel, importedStagedModel);
349            }
350    
351            protected void addComments(StagedModel stagedModel) throws Exception {
352                    if (!isCommentableStagedModel()) {
353                            return;
354                    }
355    
356                    User user = TestPropsValues.getUser();
357                    String className = ExportImportClassedModelUtil.getClassName(
358                            stagedModel);
359                    long classPK = ExportImportClassedModelUtil.getClassPK(stagedModel);
360    
361                    ServiceContext serviceContext =
362                            ServiceContextTestUtil.getServiceContext(
363                                    stagingGroup.getGroupId(), user.getUserId());
364    
365                    CommentManagerUtil.addComment(
366                            user.getUserId(), stagingGroup.getGroupId(), className, classPK,
367                            user.getFullName(), RandomTestUtil.randomString(),
368                            RandomTestUtil.randomString(50),
369                            new IdentityServiceContextFunction(serviceContext));
370            }
371    
372            protected List<StagedModel> addDependentStagedModel(
373                    Map<String, List<StagedModel>> dependentStagedModelsMap, Class<?> clazz,
374                    StagedModel dependentStagedModel) {
375    
376                    List<StagedModel> dependentStagedModels = dependentStagedModelsMap.get(
377                            clazz.getSimpleName());
378    
379                    if (dependentStagedModels == null) {
380                            dependentStagedModels = new ArrayList<>();
381    
382                            dependentStagedModelsMap.put(
383                                    clazz.getSimpleName(), dependentStagedModels);
384                    }
385    
386                    dependentStagedModels.add(dependentStagedModel);
387    
388                    return dependentStagedModels;
389            }
390    
391            protected Map<String, List<StagedModel>> addDependentStagedModelsMap(
392                            Group group)
393                    throws Exception {
394    
395                    return new HashMap<>();
396            }
397    
398            protected void addRatings(StagedModel stagedModel) throws Exception {
399                    RatingsTestUtil.addEntry(
400                            ExportImportClassedModelUtil.getClassName(stagedModel),
401                            ExportImportClassedModelUtil.getClassPK(stagedModel));
402            }
403    
404            protected abstract StagedModel addStagedModel(
405                            Group group,
406                            Map<String, List<StagedModel>> dependentStagedModelsMap)
407                    throws Exception;
408    
409            protected StagedModel addVersion(StagedModel stagedModel) throws Exception {
410                    return null;
411            }
412    
413            protected void deleteStagedModel(
414                            StagedModel stagedModel,
415                            Map<String, List<StagedModel>> dependentStagedModelsMap,
416                            Group group)
417                    throws Exception {
418    
419                    @SuppressWarnings("rawtypes")
420                    StagedModelDataHandler stagedModelDataHandler =
421                            StagedModelDataHandlerRegistryUtil.getStagedModelDataHandler(
422                                    ExportImportClassedModelUtil.getClassName(stagedModel));
423    
424                    stagedModelDataHandler.deleteStagedModel(stagedModel);
425    
426                    for (List<StagedModel> dependentStagedModels :
427                                    dependentStagedModelsMap.values()) {
428    
429                            for (StagedModel dependentStagedModel : dependentStagedModels) {
430                                    stagedModelDataHandler =
431                                            StagedModelDataHandlerRegistryUtil.
432                                                    getStagedModelDataHandler(
433                                                            ExportImportClassedModelUtil.getClassName(
434                                                                    dependentStagedModel));
435    
436                                    stagedModelDataHandler.deleteStagedModel(dependentStagedModel);
437                            }
438                    }
439            }
440    
441            protected void exportImportStagedModel(StagedModel stagedModel)
442                    throws Exception {
443    
444                    initExport();
445    
446                    StagedModelDataHandlerUtil.exportStagedModel(
447                            portletDataContext, stagedModel);
448    
449                    initImport();
450    
451                    StagedModel exportedStagedModel = readExportedStagedModel(stagedModel);
452    
453                    Assert.assertNotNull(exportedStagedModel);
454    
455                    StagedModelDataHandlerUtil.importStagedModel(
456                            portletDataContext, exportedStagedModel);
457            }
458    
459            protected AssetEntry fetchAssetEntry(StagedModel stagedModel, Group group)
460                    throws Exception {
461    
462                    return AssetEntryLocalServiceUtil.fetchEntry(
463                            group.getGroupId(), stagedModel.getUuid());
464            }
465    
466            protected Date getEndDate() {
467                    return new Date();
468            }
469    
470            protected Map<String, String[]> getParameterMap() {
471                    Map<String, String[]> parameterMap = new LinkedHashMap<>();
472    
473                    parameterMap.put(
474                            PortletDataHandlerKeys.DATA_STRATEGY,
475                            new String[] {
476                                    PortletDataHandlerKeys.DATA_STRATEGY_MIRROR_OVERWRITE
477                            });
478                    parameterMap.put(
479                            PortletDataHandlerKeys.IGNORE_LAST_PUBLISH_DATE,
480                            new String[] {Boolean.TRUE.toString()});
481                    parameterMap.put(
482                            PortletDataHandlerKeys.PORTLET_CONFIGURATION,
483                            new String[] {Boolean.TRUE.toString()});
484                    parameterMap.put(
485                            PortletDataHandlerKeys.PORTLET_CONFIGURATION_ALL,
486                            new String[] {Boolean.TRUE.toString()});
487                    parameterMap.put(
488                            PortletDataHandlerKeys.PORTLET_DATA,
489                            new String[] {Boolean.TRUE.toString()});
490                    parameterMap.put(
491                            PortletDataHandlerKeys.PORTLET_DATA_ALL,
492                            new String[] {Boolean.TRUE.toString()});
493                    parameterMap.put(
494                            PortletDataHandlerKeys.PORTLET_SETUP_ALL,
495                            new String[] {Boolean.TRUE.toString()});
496    
497                    return parameterMap;
498            }
499    
500            protected abstract StagedModel getStagedModel(String uuid, Group group);
501    
502            protected abstract Class<? extends StagedModel> getStagedModelClass();
503    
504            protected Date getStartDate() {
505                    return new Date(System.currentTimeMillis() - Time.HOUR);
506            }
507    
508            protected void initExport() throws Exception {
509                    zipWriter = ZipWriterFactoryUtil.getZipWriter();
510    
511                    portletDataContext =
512                            PortletDataContextFactoryUtil.createExportPortletDataContext(
513                                    stagingGroup.getCompanyId(), stagingGroup.getGroupId(),
514                                    getParameterMap(), getStartDate(), getEndDate(), zipWriter);
515    
516                    rootElement = SAXReaderUtil.createElement("root");
517    
518                    portletDataContext.setExportDataRootElement(rootElement);
519    
520                    missingReferencesElement = rootElement.addElement("missing-references");
521    
522                    portletDataContext.setMissingReferencesElement(
523                            missingReferencesElement);
524            }
525    
526            protected void initImport() throws Exception {
527                    userIdStrategy = new TestUserIdStrategy();
528    
529                    zipReader = ZipReaderFactoryUtil.getZipReader(zipWriter.getFile());
530    
531                    String xml = zipReader.getEntryAsString("/manifest.xml");
532    
533                    if (xml == null) {
534                            Document document = SAXReaderUtil.createDocument();
535    
536                            Element rootElement = document.addElement("root");
537    
538                            rootElement.addElement("header");
539    
540                            zipWriter.addEntry("/manifest.xml", document.asXML());
541    
542                            zipReader = ZipReaderFactoryUtil.getZipReader(zipWriter.getFile());
543                    }
544    
545                    portletDataContext =
546                            PortletDataContextFactoryUtil.createImportPortletDataContext(
547                                    liveGroup.getCompanyId(), liveGroup.getGroupId(),
548                                    getParameterMap(), userIdStrategy, zipReader);
549    
550                    portletDataContext.setImportDataRootElement(rootElement);
551    
552                    Element missingReferencesElement = rootElement.element(
553                            "missing-references");
554    
555                    if (missingReferencesElement == null) {
556                            missingReferencesElement = rootElement.addElement(
557                                    "missing-references");
558                    }
559    
560                    portletDataContext.setMissingReferencesElement(
561                            missingReferencesElement);
562    
563                    Group sourceCompanyGroup = GroupLocalServiceUtil.getCompanyGroup(
564                            stagingGroup.getCompanyId());
565    
566                    portletDataContext.setSourceCompanyGroupId(
567                            sourceCompanyGroup.getGroupId());
568    
569                    portletDataContext.setSourceCompanyId(stagingGroup.getCompanyId());
570                    portletDataContext.setSourceGroupId(stagingGroup.getGroupId());
571            }
572    
573            protected boolean isAssetPrioritySupported() {
574                    return false;
575            }
576    
577            protected boolean isCommentableStagedModel() {
578                    return false;
579            }
580    
581            protected boolean isVersionableStagedModel() {
582                    return false;
583            }
584    
585            protected StagedModel readExportedStagedModel(StagedModel stagedModel) {
586                    String stagedModelPath = ExportImportPathUtil.getModelPath(stagedModel);
587    
588                    StagedModel exportedStagedModel =
589                            (StagedModel)portletDataContext.getZipEntryAsObject(
590                                    stagedModelPath);
591    
592                    return exportedStagedModel;
593            }
594    
595            protected boolean supportLastPublishDateUpdate() {
596                    return false;
597            }
598    
599            protected StagedModelAssets updateAssetEntry(
600                            StagedModel stagedModel, Group group)
601                    throws Exception {
602    
603                    AssetEntry assetEntry = fetchAssetEntry(stagedModel, group);
604    
605                    if (assetEntry == null) {
606                            return null;
607                    }
608    
609                    AssetVocabulary assetVocabulary = AssetTestUtil.addVocabulary(
610                            stagingGroup.getGroupId());
611    
612                    AssetCategory assetCategory = AssetTestUtil.addCategory(
613                            stagingGroup.getGroupId(), assetVocabulary.getVocabularyId());
614    
615                    Company company = CompanyLocalServiceUtil.getCompany(
616                            stagedModel.getCompanyId());
617    
618                    Group companyGroup = company.getGroup();
619    
620                    AssetVocabulary companyAssetVocabulary = AssetTestUtil.addVocabulary(
621                            companyGroup.getGroupId());
622    
623                    AssetCategory companyAssetCategory = AssetTestUtil.addCategory(
624                            companyGroup.getGroupId(),
625                            companyAssetVocabulary.getVocabularyId());
626    
627                    AssetTag assetTag = AssetTestUtil.addTag(stagingGroup.getGroupId());
628    
629                    double assetPriority = assetEntry.getPriority();
630    
631                    if (isAssetPrioritySupported()) {
632                            assetPriority = RandomTestUtil.nextDouble();
633                    }
634    
635                    assetEntry = AssetEntryLocalServiceUtil.updateEntry(
636                            TestPropsValues.getUserId(), stagingGroup.getGroupId(),
637                            assetEntry.getCreateDate(), assetEntry.getModifiedDate(),
638                            assetEntry.getClassName(), assetEntry.getClassPK(),
639                            assetEntry.getClassUuid(), assetEntry.getClassTypeId(),
640                            new long[] {
641                                    assetCategory.getCategoryId(),
642                                    companyAssetCategory.getCategoryId()
643                            },
644                            new String[] {assetTag.getName()}, assetEntry.isVisible(),
645                            assetEntry.getStartDate(), assetEntry.getEndDate(),
646                            assetEntry.getExpirationDate(), assetEntry.getMimeType(),
647                            assetEntry.getTitle(), assetEntry.getDescription(),
648                            assetEntry.getSummary(), assetEntry.getUrl(),
649                            assetEntry.getLayoutUuid(), assetEntry.getHeight(),
650                            assetEntry.getWidth(), assetPriority);
651    
652                    return new StagedModelAssets(
653                            assetCategory, assetEntry, assetTag, assetVocabulary);
654            }
655    
656            protected void validateAssets(
657                            StagedModel stagedModel, StagedModelAssets stagedModelAssets,
658                            Group group)
659                    throws Exception {
660    
661                    if (stagedModelAssets == null) {
662                            return;
663                    }
664    
665                    AssetEntry importedAssetEntry = fetchAssetEntry(stagedModel, group);
666    
667                    if (isAssetPrioritySupported()) {
668                            AssetEntry assetEntry = stagedModelAssets.getAssetEntry();
669    
670                            Assert.assertEquals(
671                                    assetEntry.getPriority(), importedAssetEntry.getPriority(), 0D);
672                    }
673    
674                    List<AssetCategory> importedAssetCategories =
675                            AssetCategoryLocalServiceUtil.getEntryCategories(
676                                    importedAssetEntry.getEntryId());
677    
678                    Assert.assertEquals(2, importedAssetCategories.size());
679    
680                    AssetCategory stagedAssetCategory =
681                            stagedModelAssets.getAssetCategory();
682    
683                    AssetCategory importedAssetCategory = null;
684    
685                    Company company = CompanyLocalServiceUtil.getCompany(
686                            group.getCompanyId());
687    
688                    long companyGroupId = company.getGroupId();
689    
690                    for (AssetCategory assetCategory : importedAssetCategories) {
691                            long groupId = assetCategory.getGroupId();
692    
693                            if (groupId != companyGroupId) {
694                                    importedAssetCategory = assetCategory;
695    
696                                    break;
697                            }
698                    }
699    
700                    Assert.assertEquals(
701                            stagedAssetCategory.getUuid(), importedAssetCategory.getUuid());
702    
703                    List<AssetTag> importedAssetTags =
704                            AssetTagLocalServiceUtil.getEntryTags(
705                                    importedAssetEntry.getEntryId());
706    
707                    Assert.assertEquals(1, importedAssetTags.size());
708    
709                    AssetTag assetTag = stagedModelAssets.getAssetTag();
710                    AssetTag importedAssetTag = importedAssetTags.get(0);
711    
712                    Assert.assertEquals(assetTag.getName(), importedAssetTag.getName());
713    
714                    AssetVocabulary assetVocabulary =
715                            stagedModelAssets.getAssetVocabulary();
716                    AssetVocabulary importedAssetVocabulary =
717                            AssetVocabularyLocalServiceUtil.getVocabulary(
718                                    importedAssetCategory.getVocabularyId());
719    
720                    Assert.assertEquals(
721                            assetVocabulary.getUuid(), importedAssetVocabulary.getUuid());
722            }
723    
724            protected void validateComments(
725                            StagedModel stagedModel, StagedModel importedStagedModel,
726                            Group group)
727                    throws Exception {
728    
729                    if (!isCommentableStagedModel()) {
730                            return;
731                    }
732    
733                    List<MBMessage> discussionMBMessages =
734                            MBMessageLocalServiceUtil.getMessages(
735                                    ExportImportClassedModelUtil.getClassName(stagedModel),
736                                    ExportImportClassedModelUtil.getClassPK(stagedModel),
737                                    WorkflowConstants.STATUS_ANY);
738    
739                    if (ListUtil.isEmpty(discussionMBMessages)) {
740                            return;
741                    }
742    
743                    int importedDiscussionMBMessagesCount =
744                            MBMessageLocalServiceUtil.getDiscussionMessagesCount(
745                                    ExportImportClassedModelUtil.getClassName(importedStagedModel),
746                                    ExportImportClassedModelUtil.getClassPK(importedStagedModel),
747                                    WorkflowConstants.STATUS_ANY);
748    
749                    Assert.assertEquals(
750                            discussionMBMessages.size(), importedDiscussionMBMessagesCount + 1);
751    
752                    for (MBMessage discussionMBMessage : discussionMBMessages) {
753                            if (discussionMBMessage.isRoot()) {
754                                    continue;
755                            }
756    
757                            MBMessage importedDiscussionMBMessage =
758                                    MBMessageLocalServiceUtil.fetchMBMessageByUuidAndGroupId(
759                                            discussionMBMessage.getUuid(), group.getGroupId());
760    
761                            Assert.assertNotNull(importedDiscussionMBMessage);
762                    }
763            }
764    
765            protected void validateExport(
766                            PortletDataContext portletDataContext, StagedModel stagedModel,
767                            Map<String, List<StagedModel>> dependentStagedModelsMap)
768                    throws Exception {
769    
770                    Element rootElement = portletDataContext.getExportDataRootElement();
771    
772                    List<Element> stagedModelGroupElements = new ArrayList<>();
773    
774                    Class<?> stagedModelClass = getStagedModelClass();
775    
776                    String stagedModelClassSimpleName = stagedModelClass.getSimpleName();
777    
778                    stagedModelGroupElements.addAll(
779                            rootElement.elements(stagedModelClassSimpleName));
780    
781                    for (String dependentStagedModelClassSimpleName :
782                                    dependentStagedModelsMap.keySet()) {
783    
784                            stagedModelGroupElements.addAll(
785                                    rootElement.elements(dependentStagedModelClassSimpleName));
786                    }
787    
788                    for (Element stagedModelGroupElement : stagedModelGroupElements) {
789                            String className = stagedModelGroupElement.getName();
790    
791                            if (className.equals("missing-references")) {
792                                    continue;
793                            }
794    
795                            List<StagedModel> dependentStagedModels =
796                                    dependentStagedModelsMap.get(className);
797    
798                            if (dependentStagedModels == null) {
799                                    dependentStagedModels = new ArrayList<>();
800                            }
801                            else {
802                                    dependentStagedModels = ListUtil.copy(dependentStagedModels);
803                            }
804    
805                            if (className.equals(stagedModelClassSimpleName)) {
806                                    dependentStagedModels.add(stagedModel);
807                            }
808    
809                            List<Element> elements = stagedModelGroupElement.elements();
810    
811                            Assert.assertEquals(dependentStagedModels.size(), elements.size());
812    
813                            for (Element element : elements) {
814                                    String path = element.attributeValue("path");
815    
816                                    Assert.assertNotNull(path);
817    
818                                    Iterator<StagedModel> iterator =
819                                            dependentStagedModels.iterator();
820    
821                                    while (iterator.hasNext()) {
822                                            StagedModel dependentStagedModel = iterator.next();
823    
824                                            String dependentStagedModelPath =
825                                                    ExportImportPathUtil.getModelPath(dependentStagedModel);
826    
827                                            if (path.equals(dependentStagedModelPath)) {
828                                                    iterator.remove();
829                                            }
830                                    }
831                            }
832    
833                            Assert.assertTrue(
834                                    "There is more than one element exported with the same path",
835                                    dependentStagedModels.isEmpty());
836                    }
837            }
838    
839            protected void validateImport(
840                            Map<String, List<StagedModel>> dependentStagedModelsMap,
841                            Group group)
842                    throws Exception {
843            }
844    
845            protected void validateImport(
846                            StagedModel stagedModel, StagedModelAssets stagedModelAssets,
847                            Map<String, List<StagedModel>> dependentStagedModelsMap,
848                            Group group)
849                    throws Exception {
850    
851                    StagedModel importedStagedModel = getStagedModel(
852                            stagedModel.getUuid(), group);
853    
854                    Assert.assertNotNull(importedStagedModel);
855    
856                    validateAssets(importedStagedModel, stagedModelAssets, group);
857                    validateComments(stagedModel, importedStagedModel, group);
858                    validateImport(dependentStagedModelsMap, group);
859                    validateImportedStagedModel(stagedModel, importedStagedModel);
860                    validateRatings(stagedModel, importedStagedModel);
861            }
862    
863            protected void validateImportedStagedModel(
864                            StagedModel stagedModel, StagedModel importedStagedModel)
865                    throws Exception {
866    
867                    Assert.assertTrue(
868                            stagedModel.getCreateDate() + " " +
869                                    importedStagedModel.getCreateDate(),
870                            DateUtil.equals(
871                                    stagedModel.getCreateDate(),
872                                    importedStagedModel.getCreateDate()));
873                    Assert.assertTrue(
874                            stagedModel.getModifiedDate() + " " +
875                                    importedStagedModel.getModifiedDate(),
876                            DateUtil.equals(
877                                    stagedModel.getModifiedDate(),
878                                    importedStagedModel.getModifiedDate()));
879                    Assert.assertEquals(
880                            stagedModel.getUuid(), importedStagedModel.getUuid());
881            }
882    
883            protected void validateRatings(
884                            StagedModel stagedModel, StagedModel importedStagedModel)
885                    throws Exception {
886    
887                    List<RatingsEntry> ratingsEntries =
888                            RatingsEntryLocalServiceUtil.getEntries(
889                                    ExportImportClassedModelUtil.getClassName(stagedModel),
890                                    ExportImportClassedModelUtil.getClassPK(stagedModel),
891                                    WorkflowConstants.STATUS_ANY);
892    
893                    List<RatingsEntry> importedRatingsEntries =
894                            RatingsEntryLocalServiceUtil.getEntries(
895                                    ExportImportClassedModelUtil.getClassName(importedStagedModel),
896                                    ExportImportClassedModelUtil.getClassPK(importedStagedModel),
897                                    WorkflowConstants.STATUS_ANY);
898    
899                    Assert.assertEquals(
900                            ratingsEntries.size(), importedRatingsEntries.size());
901    
902                    for (RatingsEntry ratingsEntry : ratingsEntries) {
903                            Iterator<RatingsEntry> iterator = importedRatingsEntries.iterator();
904    
905                            while (iterator.hasNext()) {
906                                    RatingsEntry importedRatingsEntry = iterator.next();
907    
908                                    if (ratingsEntry.getScore() ==
909                                                    importedRatingsEntry.getScore()) {
910    
911                                            iterator.remove();
912    
913                                            break;
914                                    }
915                            }
916                    }
917    
918                    Assert.assertTrue(importedRatingsEntries.isEmpty());
919            }
920    
921            @DeleteAfterTestRun
922            protected Group liveGroup;
923    
924            protected Element missingReferencesElement;
925            protected PortletDataContext portletDataContext;
926            protected Element rootElement;
927    
928            @DeleteAfterTestRun
929            protected Group stagingGroup;
930    
931            protected UserIdStrategy userIdStrategy;
932            protected ZipReader zipReader;
933            protected ZipWriter zipWriter;
934    
935            protected class StagedModelAssets implements Serializable {
936    
937                    public StagedModelAssets(
938                            AssetCategory assetCategory, AssetEntry assetEntry,
939                            AssetTag assetTag, AssetVocabulary assetVocabulary) {
940    
941                            _assetCategory = assetCategory;
942                            _assetEntry = assetEntry;
943                            _assetTag = assetTag;
944                            _assetVocabulary = assetVocabulary;
945                    }
946    
947                    public AssetCategory getAssetCategory() {
948                            return _assetCategory;
949                    }
950    
951                    public AssetEntry getAssetEntry() {
952                            return _assetEntry;
953                    }
954    
955                    public AssetTag getAssetTag() {
956                            return _assetTag;
957                    }
958    
959                    public AssetVocabulary getAssetVocabulary() {
960                            return _assetVocabulary;
961                    }
962    
963                    public void setAssetCategory(AssetCategory assetCategory) {
964                            _assetCategory = assetCategory;
965                    }
966    
967                    public void setAssetEntry(AssetEntry assetEntry) {
968                            _assetEntry = assetEntry;
969                    }
970    
971                    public void setAssetTag(AssetTag assetTag) {
972                            _assetTag = assetTag;
973                    }
974    
975                    public void setAssetVocabulary(AssetVocabulary assetVocabulary) {
976                            _assetVocabulary = assetVocabulary;
977                    }
978    
979                    private AssetCategory _assetCategory;
980                    private AssetEntry _assetEntry;
981                    private AssetTag _assetTag;
982                    private AssetVocabulary _assetVocabulary;
983    
984            }
985    
986            protected class TestUserIdStrategy implements UserIdStrategy {
987    
988                    @Override
989                    public long getUserId(String userUuid) {
990                            try {
991                                    return TestPropsValues.getUserId();
992                            }
993                            catch (Exception e) {
994                                    return 0;
995                            }
996                    }
997    
998            }
999    
1000    }