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.portal.lar;
016    
017    import com.liferay.portal.NoSuchRoleException;
018    import com.liferay.portal.NoSuchTeamException;
019    import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.dao.orm.Property;
022    import com.liferay.portal.kernel.dao.orm.PropertyFactoryUtil;
023    import com.liferay.portal.kernel.exception.PortalException;
024    import com.liferay.portal.kernel.exception.SystemException;
025    import com.liferay.portal.kernel.lar.ExportImportPathUtil;
026    import com.liferay.portal.kernel.lar.ManifestSummary;
027    import com.liferay.portal.kernel.lar.PortletDataContext;
028    import com.liferay.portal.kernel.lar.PortletDataContextListener;
029    import com.liferay.portal.kernel.lar.PortletDataHandlerControl;
030    import com.liferay.portal.kernel.lar.PortletDataHandlerKeys;
031    import com.liferay.portal.kernel.lar.StagedModelDataHandlerUtil;
032    import com.liferay.portal.kernel.lar.StagedModelType;
033    import com.liferay.portal.kernel.lar.UserIdStrategy;
034    import com.liferay.portal.kernel.log.Log;
035    import com.liferay.portal.kernel.log.LogFactoryUtil;
036    import com.liferay.portal.kernel.util.ArrayUtil;
037    import com.liferay.portal.kernel.util.DateRange;
038    import com.liferay.portal.kernel.util.KeyValuePair;
039    import com.liferay.portal.kernel.util.ListUtil;
040    import com.liferay.portal.kernel.util.MapUtil;
041    import com.liferay.portal.kernel.util.PrimitiveLongList;
042    import com.liferay.portal.kernel.util.StringBundler;
043    import com.liferay.portal.kernel.util.StringPool;
044    import com.liferay.portal.kernel.util.StringUtil;
045    import com.liferay.portal.kernel.util.Validator;
046    import com.liferay.portal.kernel.workflow.WorkflowConstants;
047    import com.liferay.portal.kernel.xml.Attribute;
048    import com.liferay.portal.kernel.xml.Element;
049    import com.liferay.portal.kernel.xml.Node;
050    import com.liferay.portal.kernel.xml.SAXReaderUtil;
051    import com.liferay.portal.kernel.xml.XPath;
052    import com.liferay.portal.kernel.zip.ZipReader;
053    import com.liferay.portal.kernel.zip.ZipWriter;
054    import com.liferay.portal.model.AttachedModel;
055    import com.liferay.portal.model.AuditedModel;
056    import com.liferay.portal.model.ClassedModel;
057    import com.liferay.portal.model.Group;
058    import com.liferay.portal.model.Layout;
059    import com.liferay.portal.model.Lock;
060    import com.liferay.portal.model.Portlet;
061    import com.liferay.portal.model.PortletModel;
062    import com.liferay.portal.model.ResourceConstants;
063    import com.liferay.portal.model.ResourcedModel;
064    import com.liferay.portal.model.Role;
065    import com.liferay.portal.model.RoleConstants;
066    import com.liferay.portal.model.StagedGroupedModel;
067    import com.liferay.portal.model.StagedModel;
068    import com.liferay.portal.model.Team;
069    import com.liferay.portal.model.impl.LockImpl;
070    import com.liferay.portal.security.permission.ResourceActionsUtil;
071    import com.liferay.portal.service.GroupLocalServiceUtil;
072    import com.liferay.portal.service.LockLocalServiceUtil;
073    import com.liferay.portal.service.ResourceBlockLocalServiceUtil;
074    import com.liferay.portal.service.ResourceBlockPermissionLocalServiceUtil;
075    import com.liferay.portal.service.ResourcePermissionLocalServiceUtil;
076    import com.liferay.portal.service.RoleLocalServiceUtil;
077    import com.liferay.portal.service.ServiceContext;
078    import com.liferay.portal.service.TeamLocalServiceUtil;
079    import com.liferay.portal.util.PortalUtil;
080    import com.liferay.portal.util.PortletKeys;
081    import com.liferay.portlet.asset.model.AssetCategory;
082    import com.liferay.portlet.asset.model.AssetEntry;
083    import com.liferay.portlet.asset.model.AssetLink;
084    import com.liferay.portlet.asset.service.AssetCategoryLocalServiceUtil;
085    import com.liferay.portlet.asset.service.AssetEntryLocalServiceUtil;
086    import com.liferay.portlet.asset.service.AssetLinkLocalServiceUtil;
087    import com.liferay.portlet.asset.service.AssetTagLocalServiceUtil;
088    import com.liferay.portlet.blogs.model.impl.BlogsEntryImpl;
089    import com.liferay.portlet.bookmarks.model.impl.BookmarksEntryImpl;
090    import com.liferay.portlet.bookmarks.model.impl.BookmarksFolderImpl;
091    import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryImpl;
092    import com.liferay.portlet.documentlibrary.model.impl.DLFileShortcutImpl;
093    import com.liferay.portlet.documentlibrary.model.impl.DLFolderImpl;
094    import com.liferay.portlet.expando.model.ExpandoBridge;
095    import com.liferay.portlet.expando.model.ExpandoColumn;
096    import com.liferay.portlet.expando.service.ExpandoColumnLocalServiceUtil;
097    import com.liferay.portlet.journal.model.impl.JournalArticleImpl;
098    import com.liferay.portlet.journal.model.impl.JournalFeedImpl;
099    import com.liferay.portlet.messageboards.model.MBDiscussion;
100    import com.liferay.portlet.messageboards.model.MBMessage;
101    import com.liferay.portlet.messageboards.model.MBThread;
102    import com.liferay.portlet.messageboards.model.impl.MBBanImpl;
103    import com.liferay.portlet.messageboards.model.impl.MBCategoryImpl;
104    import com.liferay.portlet.messageboards.model.impl.MBMessageImpl;
105    import com.liferay.portlet.messageboards.model.impl.MBThreadFlagImpl;
106    import com.liferay.portlet.messageboards.service.MBMessageLocalServiceUtil;
107    import com.liferay.portlet.messageboards.service.MBThreadLocalServiceUtil;
108    import com.liferay.portlet.messageboards.service.persistence.MBDiscussionUtil;
109    import com.liferay.portlet.messageboards.service.persistence.MBMessageUtil;
110    import com.liferay.portlet.polls.model.impl.PollsChoiceImpl;
111    import com.liferay.portlet.polls.model.impl.PollsQuestionImpl;
112    import com.liferay.portlet.polls.model.impl.PollsVoteImpl;
113    import com.liferay.portlet.ratings.model.RatingsEntry;
114    import com.liferay.portlet.ratings.model.impl.RatingsEntryImpl;
115    import com.liferay.portlet.ratings.service.RatingsEntryLocalServiceUtil;
116    import com.liferay.portlet.wiki.model.impl.WikiNodeImpl;
117    import com.liferay.portlet.wiki.model.impl.WikiPageImpl;
118    
119    import com.thoughtworks.xstream.XStream;
120    
121    import java.io.IOException;
122    import java.io.InputStream;
123    import java.io.Serializable;
124    
125    import java.util.ArrayList;
126    import java.util.Collections;
127    import java.util.Date;
128    import java.util.HashMap;
129    import java.util.HashSet;
130    import java.util.List;
131    import java.util.Map;
132    import java.util.Set;
133    
134    import jodd.bean.BeanUtil;
135    
136    /**
137     * <p>
138     * Holds context information that is used during exporting and importing portlet
139     * data.
140     * </p>
141     *
142     * @author Brian Wing Shun Chan
143     * @author Raymond Aug??
144     * @author Bruno Farache
145     * @author Alexander Chow
146     * @author Mate Thurzo
147     */
148    public class PortletDataContextImpl implements PortletDataContext {
149    
150            public PortletDataContextImpl() {
151                    initXStream();
152            }
153    
154            @Override
155            public void addAssetCategories(Class<?> clazz, long classPK)
156                    throws SystemException {
157    
158                    List<AssetCategory> assetCategories =
159                            AssetCategoryLocalServiceUtil.getCategories(
160                                    clazz.getName(), classPK);
161    
162                    _assetCategoryUuidsMap.put(
163                            getPrimaryKeyString(clazz, classPK),
164                            StringUtil.split(
165                                    ListUtil.toString(
166                                            assetCategories, AssetCategory.UUID_ACCESSOR)));
167                    _assetCategoryIdsMap.put(
168                            getPrimaryKeyString(clazz, classPK),
169                            StringUtil.split(
170                                    ListUtil.toString(
171                                            assetCategories, AssetCategory.CATEGORY_ID_ACCESSOR), 0L));
172            }
173    
174            @Override
175            public void addAssetCategories(
176                    String className, long classPK, long[] assetCategoryIds) {
177    
178                    _assetCategoryIdsMap.put(
179                            getPrimaryKeyString(className, classPK), assetCategoryIds);
180            }
181    
182            public void addAssetLinks(Class<?> clazz, long classPK)
183                    throws SystemException {
184    
185                    AssetEntry assetEntry = AssetEntryLocalServiceUtil.fetchEntry(
186                            clazz.getName(), classPK);
187    
188                    if (assetEntry == null) {
189                            return;
190                    }
191    
192                    List<AssetLink> directAssetLinks =
193                            AssetLinkLocalServiceUtil.getDirectLinks(assetEntry.getEntryId());
194    
195                    if (directAssetLinks.isEmpty()) {
196                            return;
197                    }
198    
199                    Map<Integer, List<AssetLink>> assetLinksMap =
200                            new HashMap<Integer, List<AssetLink>>();
201    
202                    for (AssetLink assetLink : directAssetLinks) {
203                            List<AssetLink> assetLinks = assetLinksMap.get(assetLink.getType());
204    
205                            if (assetLinks == null) {
206                                    assetLinks = new ArrayList<AssetLink>();
207    
208                                    assetLinksMap.put(assetLink.getType(), assetLinks);
209                            }
210    
211                            assetLinks.add(assetLink);
212                    }
213    
214                    for (Map.Entry<Integer, List<AssetLink>> entry :
215                                    assetLinksMap.entrySet()) {
216    
217                            _assetLinksMap.put(
218                                    getPrimaryKeyString(assetEntry.getClassUuid(), entry.getKey()),
219                                    entry.getValue());
220                    }
221            }
222    
223            @Override
224            public void addAssetTags(Class<?> clazz, long classPK)
225                    throws SystemException {
226    
227                    String[] tagNames = AssetTagLocalServiceUtil.getTagNames(
228                            clazz.getName(), classPK);
229    
230                    _assetTagNamesMap.put(getPrimaryKeyString(clazz, classPK), tagNames);
231            }
232    
233            @Override
234            public void addAssetTags(
235                    String className, long classPK, String[] assetTagNames) {
236    
237                    _assetTagNamesMap.put(
238                            getPrimaryKeyString(className, classPK), assetTagNames);
239            }
240    
241            @Override
242            public void addClassedModel(
243                            Element element, String path, ClassedModel classedModel)
244                    throws PortalException, SystemException {
245    
246                    addClassedModel(
247                            element, path, classedModel, classedModel.getModelClass());
248            }
249    
250            @Override
251            public void addClassedModel(
252                            Element element, String path, ClassedModel classedModel,
253                            Class<?> clazz)
254                    throws PortalException, SystemException {
255    
256                    element.addAttribute("path", path);
257    
258                    if (classedModel instanceof AttachedModel) {
259                            AttachedModel attachedModel = (AttachedModel)classedModel;
260    
261                            element.addAttribute("class-name", attachedModel.getClassName());
262                    }
263                    else if (BeanUtil.hasProperty(classedModel, "className")) {
264                            String className = BeanPropertiesUtil.getStringSilent(
265                                    classedModel, "className");
266    
267                            if (className != null) {
268                                    element.addAttribute("class-name", className);
269                            }
270                    }
271    
272                    if (isPathProcessed(path)) {
273                            return;
274                    }
275    
276                    if (classedModel instanceof AuditedModel) {
277                            AuditedModel auditedModel = (AuditedModel)classedModel;
278    
279                            auditedModel.setUserUuid(auditedModel.getUserUuid());
280                    }
281    
282                    if (!isResourceMain(classedModel)) {
283                            addZipEntry(path, classedModel);
284    
285                            return;
286                    }
287    
288                    long classPK = getClassPK(classedModel);
289    
290                    addAssetCategories(clazz, classPK);
291                    addAssetLinks(clazz, classPK);
292                    addAssetTags(clazz, classPK);
293                    addExpando(element, path, classedModel, clazz);
294                    addLocks(clazz, String.valueOf(classPK));
295                    addPermissions(clazz, classPK);
296    
297                    boolean portletDataAll = MapUtil.getBoolean(
298                            getParameterMap(), PortletDataHandlerKeys.PORTLET_DATA_ALL);
299    
300                    if (portletDataAll ||
301                            MapUtil.getBoolean(
302                                    getParameterMap(), PortletDataHandlerKeys.COMMENTS)) {
303    
304                            addComments(clazz, classPK);
305                    }
306    
307                    if (portletDataAll ||
308                            MapUtil.getBoolean(
309                                    getParameterMap(), PortletDataHandlerKeys.RATINGS)) {
310    
311                            addRatingsEntries(clazz, classPK);
312                    }
313    
314                    addZipEntry(path, classedModel);
315            }
316    
317            /**
318             * @deprecated As of 6.2.0, replaced by {@link #addClassedModel(Element,
319             *             String, ClassedModel, Class)}
320             */
321            @Override
322            public void addClassedModel(
323                            Element element, String path, ClassedModel classedModel,
324                            Class<?> clazz, String namespace)
325                    throws PortalException, SystemException {
326    
327                    addClassedModel(element, path, classedModel, clazz);
328            }
329    
330            /**
331             * @deprecated As of 6.2.0, replaced by {@link #addClassedModel(Element,
332             *             String, ClassedModel)}
333             */
334            @Override
335            public void addClassedModel(
336                            Element element, String path, ClassedModel classedModel,
337                            String namespace)
338                    throws PortalException, SystemException {
339    
340                    addClassedModel(element, path, classedModel);
341            }
342    
343            @Override
344            public void addComments(Class<?> clazz, long classPK)
345                    throws SystemException {
346    
347                    long classNameId = PortalUtil.getClassNameId(clazz);
348    
349                    MBDiscussion discussion = MBDiscussionUtil.fetchByC_C(
350                            classNameId, classPK);
351    
352                    if (discussion == null) {
353                            return;
354                    }
355    
356                    List<MBMessage> messages = MBMessageLocalServiceUtil.getThreadMessages(
357                            discussion.getThreadId(), WorkflowConstants.STATUS_APPROVED);
358    
359                    if (messages.isEmpty()) {
360                            return;
361                    }
362    
363                    MBMessage firstMessage = messages.get(0);
364    
365                    if ((messages.size() == 1) && firstMessage.isRoot()) {
366                            return;
367                    }
368    
369                    for (MBMessage message : messages) {
370                            addRatingsEntries(MBDiscussion.class, message.getPrimaryKey());
371                    }
372    
373                    _commentsMap.put(getPrimaryKeyString(clazz, classPK), messages);
374            }
375    
376            @Override
377            public void addComments(
378                    String className, long classPK, List<MBMessage> messages) {
379    
380                    _commentsMap.put(getPrimaryKeyString(className, classPK), messages);
381            }
382    
383            /**
384             * @see #isWithinDateRange(Date)
385             */
386            @Override
387            public void addDateRangeCriteria(
388                    DynamicQuery dynamicQuery, String modifiedDatePropertyName) {
389    
390                    if (!hasDateRange()) {
391                            return;
392                    }
393    
394                    Property modifiedDateProperty = PropertyFactoryUtil.forName(
395                            modifiedDatePropertyName);
396    
397                    dynamicQuery.add(modifiedDateProperty.ge(_startDate));
398                    dynamicQuery.add(modifiedDateProperty.le(_endDate));
399            }
400    
401            @Override
402            public void addDeletionSystemEventStagedModelTypes(
403                    StagedModelType... stagedModelTypes) {
404    
405                    for (StagedModelType stagedModelType : stagedModelTypes) {
406                            _deletionSystemEventModelTypes.add(stagedModelType);
407                    }
408            }
409    
410            @Override
411            public void addExpando(
412                            Element element, String path, ClassedModel classedModel)
413                    throws PortalException, SystemException {
414    
415                    addExpando(element, path, classedModel, classedModel.getModelClass());
416            }
417    
418            @Override
419            public void addLocks(Class<?> clazz, String key)
420                    throws PortalException, SystemException {
421    
422                    if (!_locksMap.containsKey(getPrimaryKeyString(clazz, key)) &&
423                            LockLocalServiceUtil.isLocked(clazz.getName(), key)) {
424    
425                            Lock lock = LockLocalServiceUtil.getLock(clazz.getName(), key);
426    
427                            addLocks(clazz.getName(), key, lock);
428                    }
429            }
430    
431            @Override
432            public void addLocks(String className, String key, Lock lock) {
433                    _locksMap.put(getPrimaryKeyString(className, key), lock);
434            }
435    
436            @Override
437            public void addPermissions(Class<?> clazz, long classPK)
438                    throws PortalException, SystemException {
439    
440                    addPermissions(clazz.getName(), classPK);
441            }
442    
443            @Override
444            public void addPermissions(String resourceName, long resourcePK)
445                    throws PortalException, SystemException {
446    
447                    if (!MapUtil.getBoolean(
448                                    _parameterMap, PortletDataHandlerKeys.PERMISSIONS)) {
449    
450                            return;
451                    }
452    
453                    List<KeyValuePair> permissions = new ArrayList<KeyValuePair>();
454    
455                    List<Role> roles = RoleLocalServiceUtil.getGroupRelatedRoles(_groupId);
456    
457                    PrimitiveLongList roleIds = new PrimitiveLongList(roles.size());
458                    Map<Long, String> roleIdsToNames = new HashMap<Long, String>();
459    
460                    for (Role role : roles) {
461                            String roleName = role.getName();
462    
463                            int roleType = role.getType();
464    
465                            if ((roleType == RoleConstants.TYPE_PROVIDER) && role.isTeam()) {
466                                    Team team = TeamLocalServiceUtil.getTeam(role.getClassPK());
467    
468                                    roleName = PermissionExporter.ROLE_TEAM_PREFIX + team.getName();
469                            }
470    
471                            roleIds.add(role.getRoleId());
472                            roleIdsToNames.put(role.getRoleId(), roleName);
473                    }
474    
475                    List<String> actionIds = ResourceActionsUtil.getModelResourceActions(
476                            resourceName);
477    
478                    Map<Long, Set<String>> roleIdsToActionIds = getActionIds(
479                            _companyId, roleIds.getArray(), resourceName, resourcePK,
480                            actionIds);
481    
482                    for (Map.Entry<Long, String> entry : roleIdsToNames.entrySet()) {
483                            long roleId = entry.getKey();
484                            String name = entry.getValue();
485    
486                            Set<String> availableActionIds = roleIdsToActionIds.get(roleId);
487    
488                            if (availableActionIds == null) {
489                                    availableActionIds = Collections.emptySet();
490                            }
491    
492                            KeyValuePair permission = new KeyValuePair(
493                                    name, StringUtil.merge(availableActionIds));
494    
495                            permissions.add(permission);
496                    }
497    
498                    _permissionsMap.put(
499                            getPrimaryKeyString(resourceName, resourcePK), permissions);
500            }
501    
502            @Override
503            public void addPermissions(
504                    String resourceName, long resourcePK, List<KeyValuePair> permissions) {
505    
506                    _permissionsMap.put(
507                            getPrimaryKeyString(resourceName, resourcePK), permissions);
508            }
509    
510            @Override
511            public void addPortalPermissions() throws PortalException, SystemException {
512                    addPermissions(PortletKeys.PORTAL, getCompanyId());
513            }
514    
515            @Override
516            public void addPortletPermissions(String resourceName)
517                    throws PortalException, SystemException {
518    
519                    long groupId = getGroupId();
520    
521                    Group group = GroupLocalServiceUtil.getGroup(groupId);
522    
523                    if (group.isStagingGroup()) {
524                            if (group.isStagedRemotely()) {
525                                    groupId = group.getLiveGroupId();
526                            }
527                            else {
528                                    return;
529                            }
530                    }
531    
532                    addPermissions(resourceName, groupId);
533            }
534    
535            @Override
536            public boolean addPrimaryKey(Class<?> clazz, String primaryKey) {
537                    boolean value = hasPrimaryKey(clazz, primaryKey);
538    
539                    if (!value) {
540                            _primaryKeys.add(getPrimaryKeyString(clazz, primaryKey));
541                    }
542    
543                    return value;
544            }
545    
546            @Override
547            public void addRatingsEntries(Class<?> clazz, long classPK)
548                    throws SystemException {
549    
550                    List<RatingsEntry> ratingsEntries =
551                            RatingsEntryLocalServiceUtil.getEntries(clazz.getName(), classPK);
552    
553                    if (ratingsEntries.size() == 0) {
554                            return;
555                    }
556    
557                    _ratingsEntriesMap.put(
558                            getPrimaryKeyString(clazz, classPK), ratingsEntries);
559            }
560    
561            @Override
562            public void addRatingsEntries(
563                    String className, long classPK, List<RatingsEntry> ratingsEntries) {
564    
565                    _ratingsEntriesMap.put(
566                            getPrimaryKeyString(className, classPK), ratingsEntries);
567            }
568    
569            @Override
570            public Element addReferenceElement(
571                    ClassedModel referrerClassedModel, Element element,
572                    ClassedModel classedModel, Class<?> clazz, String referenceType,
573                    boolean missing) {
574    
575                    return addReferenceElement(
576                            referrerClassedModel, element, classedModel, clazz.getName(),
577                            StringPool.BLANK, referenceType, missing);
578            }
579    
580            @Override
581            public Element addReferenceElement(
582                    ClassedModel referrerClassedModel, Element element,
583                    ClassedModel classedModel, String referenceType, boolean missing) {
584    
585                    return addReferenceElement(
586                            referrerClassedModel, element, classedModel,
587                            classedModel.getModelClassName(), StringPool.BLANK, referenceType,
588                            missing);
589            }
590    
591            @Override
592            public Element addReferenceElement(
593                    ClassedModel referrerClassedModel, Element element,
594                    ClassedModel classedModel, String binPath, String referenceType,
595                    boolean missing) {
596    
597                    return addReferenceElement(
598                            referrerClassedModel, element, classedModel,
599                            classedModel.getModelClassName(), binPath, referenceType, missing);
600            }
601    
602            @Override
603            public Element addReferenceElement(
604                    ClassedModel referrerClassedModel, Element element,
605                    ClassedModel classedModel, String className, String binPath,
606                    String referenceType, boolean missing) {
607    
608                    Element referenceElement = doAddReferenceElement(
609                            referrerClassedModel, element, classedModel, className, binPath,
610                            referenceType, false);
611    
612                    String referenceKey = getReferenceKey(classedModel);
613    
614                    if (missing) {
615                            if (_references.contains(referenceKey)) {
616                                    return referenceElement;
617                            }
618    
619                            _missingReferences.add(referenceKey);
620    
621                            doAddReferenceElement(
622                                    referrerClassedModel, null, classedModel, className, binPath,
623                                    referenceType, true);
624                    }
625                    else {
626                            _references.add(referenceKey);
627    
628                            if (_missingReferences.contains(referenceKey)) {
629                                    _missingReferences.remove(referenceKey);
630    
631                                    Element missingReferenceElement = getMissingReferenceElement(
632                                            classedModel);
633    
634                                    _missingReferencesElement.remove(missingReferenceElement);
635                            }
636                    }
637    
638                    return referenceElement;
639            }
640    
641            @Override
642            public boolean addScopedPrimaryKey(Class<?> clazz, String primaryKey) {
643                    boolean value = hasScopedPrimaryKey(clazz, primaryKey);
644    
645                    if (!value) {
646                            _scopedPrimaryKeys.add(getPrimaryKeyString(clazz, primaryKey));
647                    }
648    
649                    return value;
650            }
651    
652            @Override
653            public void addZipEntry(String path, byte[] bytes) throws SystemException {
654                    if (_portletDataContextListener != null) {
655                            _portletDataContextListener.onAddZipEntry(path);
656                    }
657    
658                    try {
659                            ZipWriter zipWriter = getZipWriter();
660    
661                            zipWriter.addEntry(path, bytes);
662                    }
663                    catch (IOException ioe) {
664                            throw new SystemException(ioe);
665                    }
666            }
667    
668            @Override
669            public void addZipEntry(String path, InputStream is)
670                    throws SystemException {
671    
672                    if (_portletDataContextListener != null) {
673                            _portletDataContextListener.onAddZipEntry(path);
674                    }
675    
676                    try {
677                            ZipWriter zipWriter = getZipWriter();
678    
679                            zipWriter.addEntry(path, is);
680                    }
681                    catch (IOException ioe) {
682                            throw new SystemException(ioe);
683                    }
684            }
685    
686            @Override
687            public void addZipEntry(String path, Object object) throws SystemException {
688                    addZipEntry(path, toXML(object));
689            }
690    
691            @Override
692            public void addZipEntry(String path, String s) throws SystemException {
693                    if (_portletDataContextListener != null) {
694                            _portletDataContextListener.onAddZipEntry(path);
695                    }
696    
697                    try {
698                            ZipWriter zipWriter = getZipWriter();
699    
700                            zipWriter.addEntry(path, s);
701                    }
702                    catch (IOException ioe) {
703                            throw new SystemException(ioe);
704                    }
705            }
706    
707            @Override
708            public void addZipEntry(String path, StringBuilder sb)
709                    throws SystemException {
710    
711                    if (_portletDataContextListener != null) {
712                            _portletDataContextListener.onAddZipEntry(path);
713                    }
714    
715                    try {
716                            ZipWriter zipWriter = getZipWriter();
717    
718                            zipWriter.addEntry(path, sb);
719                    }
720                    catch (IOException ioe) {
721                            throw new SystemException(ioe);
722                    }
723            }
724    
725            @Override
726            public void clearScopedPrimaryKeys() {
727                    _scopedPrimaryKeys.clear();
728            }
729    
730            @Override
731            public ServiceContext createServiceContext(
732                    Element element, ClassedModel classedModel) {
733    
734                    return createServiceContext(
735                            element, null, classedModel, classedModel.getModelClass());
736            }
737    
738            /**
739             * @deprecated As of 6.2.0, replaced by {@link
740             *             #createServiceContext(Element, ClassedModel)}
741             */
742            @Override
743            public ServiceContext createServiceContext(
744                    Element element, ClassedModel classedModel, String namespace) {
745    
746                    return createServiceContext(element, classedModel);
747            }
748    
749            @Override
750            public ServiceContext createServiceContext(StagedModel stagedModel) {
751    
752                    return createServiceContext(stagedModel, stagedModel.getModelClass());
753            }
754    
755            @Override
756            public ServiceContext createServiceContext(
757                    StagedModel stagedModel, Class<?> clazz) {
758    
759                    return createServiceContext(
760                            null, ExportImportPathUtil.getModelPath(stagedModel), stagedModel,
761                            clazz);
762            }
763    
764            @Override
765            public ServiceContext createServiceContext(
766                    String path, ClassedModel classedModel) {
767    
768                    return createServiceContext(
769                            null, path, classedModel, classedModel.getModelClass());
770            }
771    
772            /**
773             * @deprecated As of 6.2.0, replaced by {@link #createServiceContext(String,
774             *             ClassedModel)}
775             */
776            @Override
777            public ServiceContext createServiceContext(
778                    String path, ClassedModel classedModel, String namespace) {
779    
780                    return createServiceContext(path, classedModel);
781            }
782    
783            @Override
784            public Object fromXML(byte[] bytes) {
785                    if (ArrayUtil.isEmpty(bytes)) {
786                            return null;
787                    }
788    
789                    return _xStream.fromXML(new String(bytes));
790            }
791    
792            @Override
793            public Object fromXML(String xml) {
794                    if (Validator.isNull(xml)) {
795                            return null;
796                    }
797    
798                    return _xStream.fromXML(xml);
799            }
800    
801            @Override
802            public long[] getAssetCategoryIds(Class<?> clazz, long classPK) {
803                    return _assetCategoryIdsMap.get(getPrimaryKeyString(clazz, classPK));
804            }
805    
806            @Override
807            public Map<String, long[]> getAssetCategoryIdsMap() {
808                    return _assetCategoryIdsMap;
809            }
810    
811            @Override
812            public Map<String, String[]> getAssetCategoryUuidsMap() {
813                    return _assetCategoryUuidsMap;
814            }
815    
816            @Override
817            public Map<String, List<AssetLink>> getAssetLinksMap() {
818                    return _assetLinksMap;
819            }
820    
821            @Override
822            public String[] getAssetTagNames(Class<?> clazz, long classPK) {
823                    return _assetTagNamesMap.get(getPrimaryKeyString(clazz, classPK));
824            }
825    
826            @Override
827            public String[] getAssetTagNames(String className, long classPK) {
828                    return _assetTagNamesMap.get(getPrimaryKeyString(className, classPK));
829            }
830    
831            @Override
832            public Map<String, String[]> getAssetTagNamesMap() {
833                    return _assetTagNamesMap;
834            }
835    
836            @Override
837            public boolean getBooleanParameter(String namespace, String name) {
838                    return getBooleanParameter(namespace, name, true);
839            }
840    
841            @Override
842            public boolean getBooleanParameter(
843                    String namespace, String name, boolean useDefaultValue) {
844    
845                    if (!useDefaultValue) {
846                            return MapUtil.getBoolean(
847                                    getParameterMap(),
848                                    PortletDataHandlerControl.getNamespacedControlName(
849                                            namespace, name));
850                    }
851    
852                    boolean defaultValue = MapUtil.getBoolean(
853                            getParameterMap(),
854                            PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT, true);
855    
856                    return MapUtil.getBoolean(
857                            getParameterMap(),
858                            PortletDataHandlerControl.getNamespacedControlName(namespace, name),
859                            defaultValue);
860            }
861    
862            @Override
863            public ClassLoader getClassLoader() {
864                    return _xStream.getClassLoader();
865            }
866    
867            @Override
868            public Map<String, List<MBMessage>> getComments() {
869                    return _commentsMap;
870            }
871    
872            @Override
873            public long getCompanyGroupId() {
874                    return _companyGroupId;
875            }
876    
877            @Override
878            public long getCompanyId() {
879                    return _companyId;
880            }
881    
882            @Override
883            public String getDataStrategy() {
884                    return _dataStrategy;
885            }
886    
887            @Override
888            public DateRange getDateRange() {
889                    DateRange dateRange = null;
890    
891                    if (hasDateRange()) {
892                            dateRange = new DateRange(_startDate, _endDate);
893                    }
894    
895                    return dateRange;
896            }
897    
898            @Override
899            public Set<StagedModelType> getDeletionSystemEventStagedModelTypes() {
900                    return _deletionSystemEventModelTypes;
901            }
902    
903            @Override
904            public Date getEndDate() {
905                    return _endDate;
906            }
907    
908            @Override
909            public Map<String, List<ExpandoColumn>> getExpandoColumns() {
910                    return _expandoColumnsMap;
911            }
912    
913            @Override
914            public Element getExportDataElement(ClassedModel classedModel) {
915                    return getExportDataElement(classedModel, classedModel.getModelClass());
916            }
917    
918            @Override
919            public Element getExportDataElement(
920                    ClassedModel classedModel, Class<?> modelClass) {
921    
922                    Element groupElement = getExportDataGroupElement(
923                            modelClass.getSimpleName());
924    
925                    Element element = null;
926    
927                    if (classedModel instanceof StagedModel) {
928                            StagedModel stagedModel = (StagedModel)classedModel;
929    
930                            String path = ExportImportPathUtil.getModelPath(stagedModel);
931    
932                            element = getDataElement(groupElement, "path", path);
933    
934                            if (element != null) {
935                                    return element;
936                            }
937    
938                            element = getDataElement(
939                                    groupElement, "uuid", stagedModel.getUuid());
940    
941                            if (element != null) {
942                                    return element;
943                            }
944                    }
945    
946                    element = groupElement.addElement("staged-model");
947    
948                    if (classedModel instanceof StagedGroupedModel) {
949                            StagedGroupedModel stagedGroupedModel =
950                                    (StagedGroupedModel)classedModel;
951    
952                            element.addAttribute(
953                                    "group-id",String.valueOf(stagedGroupedModel.getGroupId()));
954                            element.addAttribute("uuid", stagedGroupedModel.getUuid());
955                    }
956                    else if (classedModel instanceof StagedModel) {
957                            StagedModel stagedModel = (StagedModel)classedModel;
958    
959                            element.addAttribute("uuid", stagedModel.getUuid());
960                    }
961    
962                    return element;
963            }
964    
965            @Override
966            public Element getExportDataGroupElement(
967                    Class<? extends StagedModel> clazz) {
968    
969                    return getExportDataGroupElement(clazz.getSimpleName());
970            }
971    
972            @Override
973            public Element getExportDataRootElement() {
974                    return _exportDataRootElement;
975            }
976    
977            @Override
978            public long getGroupId() {
979                    return _groupId;
980            }
981    
982            @Override
983            public Element getImportDataElement(StagedModel stagedModel) {
984                    StagedModelType stagedModelType = stagedModel.getStagedModelType();
985    
986                    return getImportDataElement(
987                            stagedModelType.getClassSimpleName(), "uuid",
988                            stagedModel.getUuid());
989            }
990    
991            @Override
992            public Element getImportDataElement(
993                    String name, String attribute, String value) {
994    
995                    Element groupElement = getImportDataGroupElement(name);
996    
997                    return getDataElement(groupElement, attribute, value);
998            }
999    
1000            @Override
1001            public Element getImportDataGroupElement(
1002                    Class<? extends StagedModel> clazz) {
1003    
1004                    return getImportDataGroupElement(clazz.getSimpleName());
1005            }
1006    
1007            @Override
1008            public Element getImportDataRootElement() {
1009                    return _importDataRootElement;
1010            }
1011    
1012            @Override
1013            public Element getImportDataStagedModelElement(StagedModel stagedModel) {
1014                    String path = ExportImportPathUtil.getModelPath(stagedModel);
1015    
1016                    StagedModelType stagedModelType = stagedModel.getStagedModelType();
1017    
1018                    return getImportDataElement(
1019                            stagedModelType.getClassSimpleName(), "path", path);
1020            }
1021    
1022            @Override
1023            public String getLayoutPath(long plid) {
1024                    return ExportImportPathUtil.getLayoutPath(this, plid);
1025            }
1026    
1027            @Override
1028            public Map<String, Lock> getLocks() {
1029                    return _locksMap;
1030            }
1031    
1032            @Override
1033            public ManifestSummary getManifestSummary() {
1034                    return _manifestSummary;
1035            }
1036    
1037            @Override
1038            public Element getMissingReferencesElement() {
1039                    return _missingReferencesElement;
1040            }
1041    
1042            @Override
1043            public List<Layout> getNewLayouts() {
1044                    return _newLayouts;
1045            }
1046    
1047            @Override
1048            public Map<?, ?> getNewPrimaryKeysMap(Class<?> clazz) {
1049                    return getNewPrimaryKeysMap(clazz.getName());
1050            }
1051    
1052            @Override
1053            public Map<?, ?> getNewPrimaryKeysMap(String className) {
1054                    Map<?, ?> map = _newPrimaryKeysMaps.get(className);
1055    
1056                    if (map == null) {
1057                            map = new HashMap<Object, Object>();
1058    
1059                            _newPrimaryKeysMaps.put(className, map);
1060                    }
1061    
1062                    return map;
1063            }
1064    
1065            @Override
1066            public long getOldPlid() {
1067                    return _oldPlid;
1068            }
1069    
1070            @Override
1071            public Map<String, String[]> getParameterMap() {
1072                    return _parameterMap;
1073            }
1074    
1075            @Override
1076            public Map<String, List<KeyValuePair>> getPermissions() {
1077                    return _permissionsMap;
1078            }
1079    
1080            @Override
1081            public long getPlid() {
1082                    return _plid;
1083            }
1084    
1085            @Override
1086            public String getPortletPath(String portletId) {
1087                    return ExportImportPathUtil.getPortletPath(this, portletId);
1088            }
1089    
1090            @Override
1091            public Set<String> getPrimaryKeys() {
1092                    return _primaryKeys;
1093            }
1094    
1095            @Override
1096            public Map<String, List<RatingsEntry>> getRatingsEntries() {
1097                    return _ratingsEntriesMap;
1098            }
1099    
1100            @Override
1101            public Element getReferenceDataElement(
1102                    Element parentElement, Class<?> clazz, long classPK) {
1103    
1104                    List<Element> referenceElements = getReferenceElements(
1105                            parentElement, clazz, 0, null, classPK, null);
1106    
1107                    List<Element> referenceDataElements = getReferenceDataElements(
1108                            referenceElements, clazz);
1109    
1110                    if (referenceDataElements.isEmpty()) {
1111                            return null;
1112                    }
1113    
1114                    return referenceDataElements.get(0);
1115            }
1116    
1117            @Override
1118            public Element getReferenceDataElement(
1119                    Element parentElement, Class<?> clazz, long groupId, String uuid) {
1120    
1121                    List<Element> referenceElements = getReferenceElements(
1122                            parentElement, clazz, groupId, uuid, 0, null);
1123    
1124                    List<Element> referenceDataElements = getReferenceDataElements(
1125                            referenceElements, clazz);
1126    
1127                    if (referenceDataElements.isEmpty()) {
1128                            return null;
1129                    }
1130    
1131                    return referenceDataElements.get(0);
1132            }
1133    
1134            @Override
1135            public Element getReferenceDataElement(
1136                    StagedModel parentStagedModel, Class<?> clazz, long classPK) {
1137    
1138                    Element parentElement = getImportDataStagedModelElement(
1139                            parentStagedModel);
1140    
1141                    return getReferenceDataElement(parentElement, clazz, classPK);
1142            }
1143    
1144            @Override
1145            public Element getReferenceDataElement(
1146                    StagedModel parentStagedModel, Class<?> clazz, long groupId,
1147                    String uuid) {
1148    
1149                    Element parentElement = getImportDataStagedModelElement(
1150                            parentStagedModel);
1151    
1152                    return getReferenceDataElement(parentElement, clazz, groupId, uuid);
1153            }
1154    
1155            @Override
1156            public List<Element> getReferenceDataElements(
1157                    Element parentElement, Class<?> clazz) {
1158    
1159                    return getReferenceDataElements(parentElement, clazz, null);
1160            }
1161    
1162            @Override
1163            public List<Element> getReferenceDataElements(
1164                    Element parentElement, Class<?> clazz, String referenceType) {
1165    
1166                    List<Element> referenceElements = getReferenceElements(
1167                            parentElement, clazz, 0, null, 0, referenceType);
1168    
1169                    return getReferenceDataElements(referenceElements, clazz);
1170            }
1171    
1172            @Override
1173            public List<Element> getReferenceDataElements(
1174                    StagedModel parentStagedModel, Class<?> clazz) {
1175    
1176                    return getReferenceDataElements(parentStagedModel, clazz, null);
1177            }
1178    
1179            @Override
1180            public List<Element> getReferenceDataElements(
1181                    StagedModel parentStagedModel, Class<?> clazz, String referenceType) {
1182    
1183                    List<Element> referenceElements = getReferenceElements(
1184                            parentStagedModel, clazz, 0, referenceType);
1185    
1186                    return getReferenceDataElements(referenceElements, clazz);
1187            }
1188    
1189            @Override
1190            public Element getReferenceElement(
1191                    StagedModel parentStagedModel, Class<?> clazz, long classPK) {
1192    
1193                    List<Element> referenceElements = getReferenceElements(
1194                            parentStagedModel, clazz, classPK, null);
1195    
1196                    if (!referenceElements.isEmpty()) {
1197                            return referenceElements.get(0);
1198                    }
1199    
1200                    return null;
1201            }
1202    
1203            @Override
1204            public List<Element> getReferenceElements(
1205                    StagedModel parentStagedModel, Class<?> clazz) {
1206    
1207                    return getReferenceElements(parentStagedModel, clazz, 0, null);
1208            }
1209    
1210            @Override
1211            public String getRootPath() {
1212                    return ExportImportPathUtil.getRootPath(this);
1213            }
1214    
1215            @Override
1216            public Set<String> getScopedPrimaryKeys() {
1217                    return _scopedPrimaryKeys;
1218            }
1219    
1220            @Override
1221            public long getScopeGroupId() {
1222                    return _scopeGroupId;
1223            }
1224    
1225            @Override
1226            public String getScopeLayoutUuid() {
1227                    return _scopeLayoutUuid;
1228            }
1229    
1230            @Override
1231            public String getScopeType() {
1232                    return _scopeType;
1233            }
1234    
1235            @Override
1236            public long getSourceCompanyGroupId() {
1237                    return _sourceCompanyGroupId;
1238            }
1239    
1240            @Override
1241            public long getSourceCompanyId() {
1242                    return _sourceCompanyId;
1243            }
1244    
1245            @Override
1246            public long getSourceGroupId() {
1247                    return _sourceGroupId;
1248            }
1249    
1250            @Override
1251            public String getSourceLayoutPath(long layoutId) {
1252                    return ExportImportPathUtil.getSourceLayoutPath(this, layoutId);
1253            }
1254    
1255            @Override
1256            public String getSourcePortletPath(String portletId) {
1257                    return ExportImportPathUtil.getSourcePortletPath(this, portletId);
1258            }
1259    
1260            @Override
1261            public String getSourceRootPath() {
1262                    return ExportImportPathUtil.getSourceRootPath(this);
1263            }
1264    
1265            @Override
1266            public long getSourceUserPersonalSiteGroupId() {
1267                    return _sourceUserPersonalSiteGroupId;
1268            }
1269    
1270            @Override
1271            public Date getStartDate() {
1272                    return _startDate;
1273            }
1274    
1275            @Override
1276            public long getUserId(String userUuid) {
1277                    return _userIdStrategy.getUserId(userUuid);
1278            }
1279    
1280            @Override
1281            public UserIdStrategy getUserIdStrategy() {
1282                    return _userIdStrategy;
1283            }
1284    
1285            @Override
1286            public long getUserPersonalSiteGroupId() {
1287                    return _userPersonalSiteGroupId;
1288            }
1289    
1290            @Override
1291            public List<String> getZipEntries() {
1292                    return getZipReader().getEntries();
1293            }
1294    
1295            @Override
1296            public byte[] getZipEntryAsByteArray(String path) {
1297                    if (!Validator.isFilePath(path, false)) {
1298                            return null;
1299                    }
1300    
1301                    if (_portletDataContextListener != null) {
1302                            _portletDataContextListener.onGetZipEntry(path);
1303                    }
1304    
1305                    return getZipReader().getEntryAsByteArray(path);
1306            }
1307    
1308            @Override
1309            public InputStream getZipEntryAsInputStream(String path) {
1310                    if (!Validator.isFilePath(path, false)) {
1311                            return null;
1312                    }
1313    
1314                    if (_portletDataContextListener != null) {
1315                            _portletDataContextListener.onGetZipEntry(path);
1316                    }
1317    
1318                    return getZipReader().getEntryAsInputStream(path);
1319            }
1320    
1321            @Override
1322            public Object getZipEntryAsObject(Element element, String path) {
1323                    Object object = fromXML(getZipEntryAsString(path));
1324    
1325                    Attribute classNameAttribute = element.attribute("class-name");
1326    
1327                    if (classNameAttribute != null) {
1328                            BeanPropertiesUtil.setProperty(
1329                                    object, "className", classNameAttribute.getText());
1330                    }
1331    
1332                    return object;
1333            }
1334    
1335            @Override
1336            public Object getZipEntryAsObject(String path) {
1337                    return fromXML(getZipEntryAsString(path));
1338            }
1339    
1340            @Override
1341            public String getZipEntryAsString(String path) {
1342                    if (!Validator.isFilePath(path, false)) {
1343                            return null;
1344                    }
1345    
1346                    if (_portletDataContextListener != null) {
1347                            _portletDataContextListener.onGetZipEntry(path);
1348                    }
1349    
1350                    return getZipReader().getEntryAsString(path);
1351            }
1352    
1353            @Override
1354            public List<String> getZipFolderEntries() {
1355                    return getZipFolderEntries(StringPool.SLASH);
1356            }
1357    
1358            @Override
1359            public List<String> getZipFolderEntries(String path) {
1360                    if (!Validator.isFilePath(path, false)) {
1361                            return null;
1362                    }
1363    
1364                    return getZipReader().getFolderEntries(path);
1365            }
1366    
1367            @Override
1368            public ZipReader getZipReader() {
1369                    return _zipReader;
1370            }
1371    
1372            @Override
1373            public ZipWriter getZipWriter() {
1374                    return _zipWriter;
1375            }
1376    
1377            @Override
1378            public boolean hasDateRange() {
1379                    if (_startDate != null) {
1380                            return true;
1381                    }
1382                    else {
1383                            return false;
1384                    }
1385            }
1386    
1387            @Override
1388            public boolean hasNotUniquePerLayout(String dataKey) {
1389                    return _notUniquePerLayout.contains(dataKey);
1390            }
1391    
1392            @Override
1393            public boolean hasPrimaryKey(Class<?> clazz, String primaryKey) {
1394                    return _primaryKeys.contains(getPrimaryKeyString(clazz, primaryKey));
1395            }
1396    
1397            @Override
1398            public boolean hasScopedPrimaryKey(Class<?> clazz, String primaryKey) {
1399                    return _scopedPrimaryKeys.contains(
1400                            getPrimaryKeyString(clazz, primaryKey));
1401            }
1402    
1403            @Override
1404            public void importClassedModel(
1405                            ClassedModel classedModel, ClassedModel newClassedModel)
1406                    throws PortalException, SystemException {
1407    
1408                    importClassedModel(
1409                            classedModel, newClassedModel, classedModel.getModelClass());
1410            }
1411    
1412            @Override
1413            public void importClassedModel(
1414                            ClassedModel classedModel, ClassedModel newClassedModel,
1415                            Class<?> clazz)
1416                    throws PortalException, SystemException {
1417    
1418                    if (!isResourceMain(classedModel)) {
1419                            return;
1420                    }
1421    
1422                    long classPK = getClassPK(classedModel);
1423    
1424                    long newClassPK = getClassPK(newClassedModel);
1425    
1426                    Map<Long, Long> newPrimaryKeysMap =
1427                            (Map<Long, Long>)getNewPrimaryKeysMap(clazz);
1428    
1429                    newPrimaryKeysMap.put(classPK, newClassPK);
1430    
1431                    importLocks(clazz, String.valueOf(classPK), String.valueOf(newClassPK));
1432                    importPermissions(clazz, classPK, newClassPK);
1433    
1434                    boolean portletDataAll = MapUtil.getBoolean(
1435                            getParameterMap(), PortletDataHandlerKeys.PORTLET_DATA_ALL);
1436    
1437                    if (portletDataAll ||
1438                            MapUtil.getBoolean(
1439                                    getParameterMap(), PortletDataHandlerKeys.COMMENTS)) {
1440    
1441                            importComments(clazz, classPK, newClassPK, getScopeGroupId());
1442                    }
1443    
1444                    if (portletDataAll ||
1445                            MapUtil.getBoolean(
1446                                    getParameterMap(), PortletDataHandlerKeys.RATINGS)) {
1447    
1448                            importRatingsEntries(clazz, classPK, newClassPK);
1449                    }
1450            }
1451    
1452            /**
1453             * @deprecated As of 6.2.0, replaced by {@link
1454             *             #importClassedModel(ClassedModel, ClassedModel, Class)}
1455             */
1456            @Override
1457            public void importClassedModel(
1458                            ClassedModel classedModel, ClassedModel newClassedModel,
1459                            Class<?> clazz, String namespace)
1460                    throws PortalException, SystemException {
1461    
1462                    importClassedModel(classedModel, newClassedModel, clazz);
1463            }
1464    
1465            /**
1466             * @deprecated As of 6.2.0, replaced by {@link
1467             *             #importClassedModel(ClassedModel, ClassedModel)}
1468             */
1469            @Override
1470            public void importClassedModel(
1471                            ClassedModel classedModel, ClassedModel newClassedModel,
1472                            String namespace)
1473                    throws PortalException, SystemException {
1474    
1475                    importClassedModel(
1476                            classedModel, newClassedModel, classedModel.getModelClass());
1477            }
1478    
1479            @Override
1480            public void importComments(
1481                            Class<?> clazz, long classPK, long newClassPK, long groupId)
1482                    throws PortalException, SystemException {
1483    
1484                    Map<Long, Long> messagePKs = new HashMap<Long, Long>();
1485                    Map<Long, Long> threadPKs = new HashMap<Long, Long>();
1486    
1487                    List<MBMessage> messages = _commentsMap.get(
1488                            getPrimaryKeyString(clazz, classPK));
1489    
1490                    if (messages == null) {
1491                            return;
1492                    }
1493    
1494                    MBMessage firstMessage = messages.get(0);
1495    
1496                    if ((messages.size() == 1) && firstMessage.isRoot()) {
1497                            return;
1498                    }
1499    
1500                    long classNameId = PortalUtil.getClassNameId(clazz);
1501    
1502                    MBDiscussion discussion = MBDiscussionUtil.fetchByC_C(
1503                            classNameId, newClassPK);
1504    
1505                    for (MBMessage message : messages) {
1506                            long userId = getUserId(message.getUserUuid());
1507                            long parentMessageId = MapUtil.getLong(
1508                                    messagePKs, message.getParentMessageId(),
1509                                    message.getParentMessageId());
1510                            long threadId = MapUtil.getLong(
1511                                    threadPKs, message.getThreadId(), message.getThreadId());
1512    
1513                            if (message.isRoot()) {
1514                                    if (discussion != null) {
1515                                            MBThread thread = MBThreadLocalServiceUtil.getThread(
1516                                                    discussion.getThreadId());
1517    
1518                                            long rootMessageId = thread.getRootMessageId();
1519    
1520                                            messagePKs.put(message.getMessageId(), rootMessageId);
1521                                            threadPKs.put(message.getThreadId(), thread.getThreadId());
1522                                    }
1523                                    else if (clazz == Layout.class) {
1524                                            MBMessage importedMessage =
1525                                                    MBMessageLocalServiceUtil.addDiscussionMessage(
1526                                                            userId, message.getUserName(), groupId,
1527                                                            clazz.getName(), newClassPK,
1528                                                            WorkflowConstants.ACTION_PUBLISH);
1529    
1530                                            messagePKs.put(
1531                                                    message.getMessageId(), importedMessage.getMessageId());
1532                                            threadPKs.put(
1533                                                    message.getThreadId(), importedMessage.getThreadId());
1534                                    }
1535                            }
1536                            else {
1537                                    ServiceContext serviceContext = new ServiceContext();
1538    
1539                                    serviceContext.setCreateDate(message.getCreateDate());
1540                                    serviceContext.setModifiedDate(message.getModifiedDate());
1541                                    serviceContext.setScopeGroupId(groupId);
1542    
1543                                    MBMessage importedMessage = null;
1544    
1545                                    if (_dataStrategy.equals(
1546                                                    PortletDataHandlerKeys.DATA_STRATEGY_MIRROR) ||
1547                                            _dataStrategy.equals(
1548                                                    PortletDataHandlerKeys.
1549                                                            DATA_STRATEGY_MIRROR_OVERWRITE)) {
1550    
1551                                            MBMessage existingMessage = MBMessageUtil.fetchByUUID_G(
1552                                                    message.getUuid(), groupId);
1553    
1554                                            if (existingMessage == null) {
1555                                                    serviceContext.setUuid(message.getUuid());
1556    
1557                                                    importedMessage =
1558                                                            MBMessageLocalServiceUtil.addDiscussionMessage(
1559                                                                    userId, message.getUserName(), groupId,
1560                                                                    clazz.getName(), newClassPK, threadId,
1561                                                                    parentMessageId, message.getSubject(),
1562                                                                    message.getBody(), serviceContext);
1563                                            }
1564                                            else {
1565                                                    serviceContext.setWorkflowAction(
1566                                                            WorkflowConstants.ACTION_PUBLISH);
1567    
1568                                                    importedMessage =
1569                                                            MBMessageLocalServiceUtil.updateDiscussionMessage(
1570                                                                    userId, existingMessage.getMessageId(),
1571                                                                    clazz.getName(), newClassPK,
1572                                                                    message.getSubject(), message.getBody(),
1573                                                                    serviceContext);
1574                                            }
1575                                    }
1576                                    else {
1577                                            importedMessage =
1578                                                    MBMessageLocalServiceUtil.addDiscussionMessage(
1579                                                            userId, message.getUserName(), groupId,
1580                                                            clazz.getName(), newClassPK, threadId,
1581                                                            parentMessageId, message.getSubject(),
1582                                                            message.getBody(), serviceContext);
1583                                    }
1584    
1585                                    messagePKs.put(
1586                                            message.getMessageId(), importedMessage.getMessageId());
1587                                    threadPKs.put(
1588                                            message.getThreadId(), importedMessage.getThreadId());
1589                            }
1590    
1591                            importRatingsEntries(
1592                                    MBDiscussion.class, message.getPrimaryKey(),
1593                                    messagePKs.get(message.getPrimaryKey()));
1594                    }
1595            }
1596    
1597            @Override
1598            public void importLocks(Class<?> clazz, String key, String newKey)
1599                    throws PortalException, SystemException {
1600    
1601                    Lock lock = _locksMap.get(getPrimaryKeyString(clazz, key));
1602    
1603                    if (lock == null) {
1604                            return;
1605                    }
1606    
1607                    long userId = getUserId(lock.getUserUuid());
1608    
1609                    long expirationTime = 0;
1610    
1611                    if (lock.getExpirationDate() != null) {
1612                            Date expirationDate = lock.getExpirationDate();
1613    
1614                            expirationTime = expirationDate.getTime();
1615                    }
1616    
1617                    LockLocalServiceUtil.lock(
1618                            userId, clazz.getName(), newKey, lock.getOwner(),
1619                            lock.isInheritable(), expirationTime);
1620            }
1621    
1622            @Override
1623            public void importPermissions(Class<?> clazz, long classPK, long newClassPK)
1624                    throws PortalException, SystemException {
1625    
1626                    importPermissions(clazz.getName(), classPK, newClassPK);
1627            }
1628    
1629            @Override
1630            public void importPermissions(
1631                            String resourceName, long resourcePK, long newResourcePK)
1632                    throws PortalException, SystemException {
1633    
1634                    if (!MapUtil.getBoolean(
1635                                    _parameterMap, PortletDataHandlerKeys.PERMISSIONS)) {
1636    
1637                            return;
1638                    }
1639    
1640                    List<KeyValuePair> permissions = _permissionsMap.get(
1641                            getPrimaryKeyString(resourceName, resourcePK));
1642    
1643                    if (permissions == null) {
1644                            return;
1645                    }
1646    
1647                    Map<Long, String[]> roleIdsToActionIds = new HashMap<Long, String[]>();
1648    
1649                    for (KeyValuePair permission : permissions) {
1650                            String roleName = permission.getKey();
1651    
1652                            Role role = null;
1653    
1654                            Team team = null;
1655    
1656                            if (roleName.startsWith(PermissionExporter.ROLE_TEAM_PREFIX)) {
1657                                    roleName = roleName.substring(
1658                                            PermissionExporter.ROLE_TEAM_PREFIX.length());
1659    
1660                                    try {
1661                                            team = TeamLocalServiceUtil.getTeam(_groupId, roleName);
1662                                    }
1663                                    catch (NoSuchTeamException nste) {
1664                                            if (_log.isWarnEnabled()) {
1665                                                    _log.warn("Team " + roleName + " does not exist");
1666                                            }
1667    
1668                                            continue;
1669                                    }
1670                            }
1671    
1672                            try {
1673                                    if (team != null) {
1674                                            role = RoleLocalServiceUtil.getTeamRole(
1675                                                    _companyId, team.getTeamId());
1676                                    }
1677                                    else {
1678                                            role = RoleLocalServiceUtil.getRole(_companyId, roleName);
1679                                    }
1680                            }
1681                            catch (NoSuchRoleException nsre) {
1682                                    if (_log.isWarnEnabled()) {
1683                                            _log.warn("Role " + roleName + " does not exist");
1684                                    }
1685    
1686                                    continue;
1687                            }
1688    
1689                            String[] actionIds = StringUtil.split(permission.getValue());
1690    
1691                            roleIdsToActionIds.put(role.getRoleId(), actionIds);
1692                    }
1693    
1694                    if (roleIdsToActionIds.isEmpty()) {
1695                            return;
1696                    }
1697    
1698                    if (ResourceBlockLocalServiceUtil.isSupported(resourceName)) {
1699                            ResourceBlockLocalServiceUtil.setIndividualScopePermissions(
1700                                    _companyId, _groupId, resourceName, newResourcePK,
1701                                    roleIdsToActionIds);
1702                    }
1703                    else {
1704                            ResourcePermissionLocalServiceUtil.setResourcePermissions(
1705                                    _companyId, resourceName, ResourceConstants.SCOPE_INDIVIDUAL,
1706                                    String.valueOf(newResourcePK), roleIdsToActionIds);
1707                    }
1708            }
1709    
1710            @Override
1711            public void importPortalPermissions()
1712                    throws PortalException, SystemException {
1713    
1714                    importPermissions(
1715                            PortletKeys.PORTAL, getSourceCompanyId(), getCompanyId());
1716            }
1717    
1718            @Override
1719            public void importPortletPermissions(String resourceName)
1720                    throws PortalException, SystemException {
1721    
1722                    importPermissions(resourceName, getSourceGroupId(), getScopeGroupId());
1723            }
1724    
1725            @Override
1726            public void importRatingsEntries(
1727                            Class<?> clazz, long classPK, long newClassPK)
1728                    throws PortalException, SystemException {
1729    
1730                    List<RatingsEntry> ratingsEntries = _ratingsEntriesMap.get(
1731                            getPrimaryKeyString(clazz, classPK));
1732    
1733                    if (ratingsEntries == null) {
1734                            return;
1735                    }
1736    
1737                    ServiceContext serviceContext = new ServiceContext();
1738    
1739                    for (RatingsEntry ratingsEntry : ratingsEntries) {
1740                            long userId = getUserId(ratingsEntry.getUserUuid());
1741    
1742                            serviceContext.setCreateDate(ratingsEntry.getCreateDate());
1743                            serviceContext.setModifiedDate(ratingsEntry.getModifiedDate());
1744    
1745                            RatingsEntryLocalServiceUtil.updateEntry(
1746                                    userId, clazz.getName(), newClassPK, ratingsEntry.getScore(),
1747                                    serviceContext);
1748                    }
1749            }
1750    
1751            @Override
1752            public boolean isCompanyStagedGroupedModel(
1753                    StagedGroupedModel stagedGroupedModel) {
1754    
1755                    if ((stagedGroupedModel.getGroupId() == getCompanyGroupId()) &&
1756                            (getGroupId() != getCompanyGroupId())) {
1757    
1758                            return true;
1759                    }
1760    
1761                    return false;
1762            }
1763    
1764            @Override
1765            public boolean isDataStrategyMirror() {
1766                    if (_dataStrategy.equals(PortletDataHandlerKeys.DATA_STRATEGY_MIRROR) ||
1767                            _dataStrategy.equals(
1768                                    PortletDataHandlerKeys.DATA_STRATEGY_MIRROR_OVERWRITE)) {
1769    
1770                            return true;
1771                    }
1772                    else {
1773                            return false;
1774                    }
1775            }
1776    
1777            @Override
1778            public boolean isDataStrategyMirrorWithOverwriting() {
1779                    if (_dataStrategy.equals(
1780                                    PortletDataHandlerKeys.DATA_STRATEGY_MIRROR_OVERWRITE)) {
1781    
1782                            return true;
1783                    }
1784                    else {
1785                            return false;
1786                    }
1787            }
1788    
1789            @Override
1790            public boolean isModelCounted(String className, long classPK) {
1791                    String modelCountedPrimaryKey = className.concat(
1792                            StringPool.POUND).concat(String.valueOf(classPK));
1793    
1794                    return addPrimaryKey(String.class, modelCountedPrimaryKey);
1795            }
1796    
1797            @Override
1798            public boolean isPathExportedInScope(String path) {
1799                    return addScopedPrimaryKey(String.class, path);
1800            }
1801    
1802            @Override
1803            public boolean isPathNotExportedInScope(String path) {
1804                    return !isPathExportedInScope(path);
1805            }
1806    
1807            @Override
1808            public boolean isPathNotProcessed(String path) {
1809                    return !isPathProcessed(path);
1810            }
1811    
1812            @Override
1813            public boolean isPathProcessed(String path) {
1814                    addScopedPrimaryKey(String.class, path);
1815    
1816                    return addPrimaryKey(String.class, path);
1817            }
1818    
1819            @Override
1820            public boolean isPerformDirectBinaryImport() {
1821                    return MapUtil.getBoolean(
1822                            _parameterMap, PortletDataHandlerKeys.PERFORM_DIRECT_BINARY_IMPORT);
1823            }
1824    
1825            @Override
1826            public boolean isPrivateLayout() {
1827                    return _privateLayout;
1828            }
1829    
1830            @Override
1831            public boolean isStagedModelCounted(StagedModel stagedModel) {
1832                    StagedModelType stagedModelType = stagedModel.getStagedModelType();
1833    
1834                    return isModelCounted(
1835                            stagedModelType.getClassName(),
1836                            (Long)stagedModel.getPrimaryKeyObj());
1837            }
1838    
1839            /**
1840             * @see #addDateRangeCriteria(DynamicQuery, String)
1841             */
1842            @Override
1843            public boolean isWithinDateRange(Date modifiedDate) {
1844                    if (!hasDateRange()) {
1845                            return true;
1846                    }
1847                    else if ((_startDate.compareTo(modifiedDate) <= 0) &&
1848                                     _endDate.after(modifiedDate)) {
1849    
1850                            return true;
1851                    }
1852                    else {
1853                            return false;
1854                    }
1855            }
1856    
1857            @Override
1858            public void putNotUniquePerLayout(String dataKey) {
1859                    _notUniquePerLayout.add(dataKey);
1860            }
1861    
1862            @Override
1863            public void setClassLoader(ClassLoader classLoader) {
1864                    _xStream.setClassLoader(classLoader);
1865            }
1866    
1867            @Override
1868            public void setCompanyGroupId(long companyGroupId) {
1869                    _companyGroupId = companyGroupId;
1870            }
1871    
1872            @Override
1873            public void setCompanyId(long companyId) {
1874                    _companyId = companyId;
1875            }
1876    
1877            @Override
1878            public void setDataStrategy(String dataStrategy) {
1879                    _dataStrategy = dataStrategy;
1880            }
1881    
1882            @Override
1883            public void setEndDate(Date endDate) {
1884                    _endDate = endDate;
1885            }
1886    
1887            @Override
1888            public void setExportDataRootElement(Element exportDataRootElement) {
1889                    _exportDataRootElement = exportDataRootElement;
1890            }
1891    
1892            @Override
1893            public void setGroupId(long groupId) {
1894                    _groupId = groupId;
1895            }
1896    
1897            @Override
1898            public void setImportDataRootElement(Element importDataRootElement) {
1899                    _importDataRootElement = importDataRootElement;
1900            }
1901    
1902            @Override
1903            public void setManifestSummary(ManifestSummary manifestSummary) {
1904                    _manifestSummary = manifestSummary;
1905            }
1906    
1907            @Override
1908            public void setMissingReferencesElement(Element missingReferencesElement) {
1909                    _missingReferencesElement = missingReferencesElement;
1910            }
1911    
1912            @Override
1913            public void setNewLayouts(List<Layout> newLayouts) {
1914                    _newLayouts = newLayouts;
1915            }
1916    
1917            @Override
1918            public void setOldPlid(long oldPlid) {
1919                    _oldPlid = oldPlid;
1920            }
1921    
1922            @Override
1923            public void setParameterMap(Map<String, String[]> parameterMap) {
1924                    _parameterMap = parameterMap;
1925            }
1926    
1927            @Override
1928            public void setPlid(long plid) {
1929                    _plid = plid;
1930            }
1931    
1932            @Override
1933            public void setPortetDataContextListener(
1934                    PortletDataContextListener portletDataContextListener) {
1935    
1936                    _portletDataContextListener = portletDataContextListener;
1937            }
1938    
1939            @Override
1940            public void setPrivateLayout(boolean privateLayout) {
1941                    _privateLayout = privateLayout;
1942            }
1943    
1944            @Override
1945            public void setScopeGroupId(long scopeGroupId) {
1946                    _scopeGroupId = scopeGroupId;
1947            }
1948    
1949            @Override
1950            public void setScopeLayoutUuid(String scopeLayoutUuid) {
1951                    _scopeLayoutUuid = scopeLayoutUuid;
1952            }
1953    
1954            @Override
1955            public void setScopeType(String scopeType) {
1956                    _scopeType = scopeType;
1957            }
1958    
1959            @Override
1960            public void setSourceCompanyGroupId(long sourceCompanyGroupId) {
1961                    _sourceCompanyGroupId = sourceCompanyGroupId;
1962            }
1963    
1964            @Override
1965            public void setSourceCompanyId(long sourceCompanyId) {
1966                    _sourceCompanyId = sourceCompanyId;
1967            }
1968    
1969            @Override
1970            public void setSourceGroupId(long sourceGroupId) {
1971                    _sourceGroupId = sourceGroupId;
1972            }
1973    
1974            @Override
1975            public void setSourceUserPersonalSiteGroupId(
1976                    long sourceUserPersonalSiteGroupId) {
1977    
1978                    _sourceUserPersonalSiteGroupId = sourceUserPersonalSiteGroupId;
1979            }
1980    
1981            @Override
1982            public void setStartDate(Date startDate) {
1983                    _startDate = startDate;
1984            }
1985    
1986            @Override
1987            public void setUserIdStrategy(UserIdStrategy userIdStrategy) {
1988                    _userIdStrategy = userIdStrategy;
1989            }
1990    
1991            @Override
1992            public void setUserPersonalSiteGroupId(long userPersonalSiteGroupId) {
1993                    _userPersonalSiteGroupId = userPersonalSiteGroupId;
1994            }
1995    
1996            @Override
1997            public void setZipReader(ZipReader zipReader) {
1998                    _zipReader = zipReader;
1999            }
2000    
2001            @Override
2002            public void setZipWriter(ZipWriter zipWriter) {
2003                    _zipWriter = zipWriter;
2004            }
2005    
2006            @Override
2007            public String toXML(Object object) {
2008                    return _xStream.toXML(object);
2009            }
2010    
2011            protected void addExpando(
2012                            Element element, String path, ClassedModel classedModel,
2013                            Class<?> clazz)
2014                    throws PortalException, SystemException {
2015    
2016                    String className = clazz.getName();
2017    
2018                    if (!_expandoColumnsMap.containsKey(className)) {
2019                            List<ExpandoColumn> expandoColumns =
2020                                    ExpandoColumnLocalServiceUtil.getDefaultTableColumns(
2021                                            _companyId, className);
2022    
2023                            for (ExpandoColumn expandoColumn : expandoColumns) {
2024                                    addPermissions(
2025                                            ExpandoColumn.class, expandoColumn.getColumnId());
2026                            }
2027    
2028                            _expandoColumnsMap.put(className, expandoColumns);
2029                    }
2030    
2031                    ExpandoBridge expandoBridge = classedModel.getExpandoBridge();
2032    
2033                    Map<String, Serializable> expandoBridgeAttributes =
2034                            expandoBridge.getAttributes();
2035    
2036                    if (!expandoBridgeAttributes.isEmpty()) {
2037                            String expandoPath = ExportImportPathUtil.getExpandoPath(path);
2038    
2039                            element.addAttribute("expando-path", expandoPath);
2040    
2041                            addZipEntry(expandoPath, expandoBridgeAttributes);
2042                    }
2043            }
2044    
2045            protected ServiceContext createServiceContext(
2046                    Element element, String path, ClassedModel classedModel,
2047                    Class<?> clazz) {
2048    
2049                    long classPK = getClassPK(classedModel);
2050    
2051                    ServiceContext serviceContext = new ServiceContext();
2052    
2053                    // Theme display
2054    
2055                    serviceContext.setCompanyId(getCompanyId());
2056                    serviceContext.setScopeGroupId(getScopeGroupId());
2057    
2058                    // Dates
2059    
2060                    if (classedModel instanceof AuditedModel) {
2061                            AuditedModel auditedModel = (AuditedModel)classedModel;
2062    
2063                            serviceContext.setUserId(getUserId(auditedModel));
2064                            serviceContext.setCreateDate(auditedModel.getCreateDate());
2065                            serviceContext.setModifiedDate(auditedModel.getModifiedDate());
2066                    }
2067    
2068                    // Permissions
2069    
2070                    if (!MapUtil.getBoolean(
2071                                    _parameterMap, PortletDataHandlerKeys.PERMISSIONS)) {
2072    
2073                            serviceContext.setAddGroupPermissions(true);
2074                            serviceContext.setAddGuestPermissions(true);
2075                    }
2076    
2077                    // Asset
2078    
2079                    if (isResourceMain(classedModel)) {
2080                            long[] assetCategoryIds = getAssetCategoryIds(clazz, classPK);
2081    
2082                            serviceContext.setAssetCategoryIds(assetCategoryIds);
2083    
2084                            String[] assetTagNames = getAssetTagNames(clazz, classPK);
2085    
2086                            serviceContext.setAssetTagNames(assetTagNames);
2087                    }
2088    
2089                    // Expando
2090    
2091                    String expandoPath = null;
2092    
2093                    if (element != null) {
2094                            expandoPath = element.attributeValue("expando-path");
2095                    }
2096                    else {
2097                            expandoPath = ExportImportPathUtil.getExpandoPath(path);
2098                    }
2099    
2100                    if (Validator.isNotNull(expandoPath)) {
2101                            try {
2102                                    Map<String, Serializable> expandoBridgeAttributes =
2103                                            (Map<String, Serializable>)getZipEntryAsObject(expandoPath);
2104    
2105                                    if (expandoBridgeAttributes != null) {
2106                                            serviceContext.setExpandoBridgeAttributes(
2107                                                    expandoBridgeAttributes);
2108                                    }
2109                            }
2110                            catch (Exception e) {
2111                                    if (_log.isDebugEnabled()) {
2112                                            _log.debug(e, e);
2113                                    }
2114                            }
2115                    }
2116    
2117                    return serviceContext;
2118            }
2119    
2120            protected Element doAddReferenceElement(
2121                    ClassedModel referrerClassedModel, Element element,
2122                    ClassedModel classedModel, String className, String binPath,
2123                    String referenceType, boolean missing) {
2124    
2125                    Element referenceElement = null;
2126    
2127                    if (missing) {
2128                            Element referencesElement = _missingReferencesElement;
2129    
2130                            referenceElement = referencesElement.addElement(
2131                                    "missing-reference");
2132                    }
2133                    else {
2134                            Element referencesElement = element.element("references");
2135    
2136                            if (referencesElement == null) {
2137                                    referencesElement = element.addElement("references");
2138                            }
2139    
2140                            referenceElement = referencesElement.addElement("reference");
2141                    }
2142    
2143                    referenceElement.addAttribute("class-name", className);
2144    
2145                    referenceElement.addAttribute(
2146                            "class-pk", String.valueOf(classedModel.getPrimaryKeyObj()));
2147    
2148                    if (missing) {
2149                            if (classedModel instanceof StagedModel) {
2150                                    referenceElement.addAttribute(
2151                                            "display-name",
2152                                            StagedModelDataHandlerUtil.getDisplayName(
2153                                                    (StagedModel)classedModel));
2154                            }
2155                            else {
2156                                    referenceElement.addAttribute(
2157                                            "display-name",
2158                                            String.valueOf(classedModel.getPrimaryKeyObj()));
2159                            }
2160                    }
2161    
2162                    if (classedModel instanceof StagedGroupedModel) {
2163                            StagedGroupedModel stagedGroupedModel =
2164                                    (StagedGroupedModel)classedModel;
2165    
2166                            referenceElement.addAttribute(
2167                                    "group-id", String.valueOf(stagedGroupedModel.getGroupId()));
2168                    }
2169    
2170                    if (Validator.isNotNull(binPath)) {
2171                            referenceElement.addAttribute("path", binPath);
2172                    }
2173    
2174                    referenceElement.addAttribute("type", referenceType);
2175    
2176                    if (missing) {
2177                            referenceElement.addAttribute(
2178                                    "referrer-class-name",
2179                                    referrerClassedModel.getModelClassName());
2180    
2181                            if (referrerClassedModel instanceof PortletModel) {
2182                                    Portlet portlet = (Portlet)referrerClassedModel;
2183    
2184                                    referenceElement.addAttribute(
2185                                            "referrer-display-name", portlet.getRootPortletId());
2186                            }
2187                            else if (referrerClassedModel instanceof StagedModel) {
2188                                    StagedModel referrerStagedModel =
2189                                            (StagedModel)referrerClassedModel;
2190    
2191                                    referenceElement.addAttribute(
2192                                            "referrer-display-name",
2193                                            StagedModelDataHandlerUtil.getDisplayName(
2194                                                    referrerStagedModel));
2195                            }
2196                    }
2197    
2198                    if (classedModel instanceof StagedModel) {
2199                            StagedModel stagedModel = (StagedModel)classedModel;
2200    
2201                            referenceElement.addAttribute("uuid", stagedModel.getUuid());
2202                            referenceElement.addAttribute(
2203                                    "company-id", String.valueOf(stagedModel.getCompanyId()));
2204    
2205                            Map<String, String> referenceAttributes =
2206                                    StagedModelDataHandlerUtil.getReferenceAttributes(
2207                                            this, stagedModel);
2208    
2209                            for (Map.Entry<String, String> referenceAttribute :
2210                                            referenceAttributes.entrySet()) {
2211    
2212                                    referenceElement.addAttribute(
2213                                            referenceAttribute.getKey(), referenceAttribute.getValue());
2214                            }
2215                    }
2216    
2217                    return referenceElement;
2218            }
2219    
2220            protected Map<Long, Set<String>> getActionIds(
2221                            long companyId, long[] roleIds, String className, long primKey,
2222                            List<String> actionIds)
2223                    throws PortalException, SystemException {
2224    
2225                    if (ResourceBlockLocalServiceUtil.isSupported(className)) {
2226                            return ResourceBlockPermissionLocalServiceUtil.
2227                                    getAvailableResourceBlockPermissionActionIds(
2228                                            roleIds, className, primKey, actionIds);
2229                    }
2230                    else {
2231                            return ResourcePermissionLocalServiceUtil.
2232                                    getAvailableResourcePermissionActionIds(
2233                                            companyId, className, ResourceConstants.SCOPE_INDIVIDUAL,
2234                                            String.valueOf(primKey), roleIds, actionIds);
2235                    }
2236            }
2237    
2238            protected long getClassPK(ClassedModel classedModel) {
2239                    if (classedModel instanceof ResourcedModel) {
2240                            ResourcedModel resourcedModel = (ResourcedModel)classedModel;
2241    
2242                            return resourcedModel.getResourcePrimKey();
2243                    }
2244                    else {
2245                            return (Long)classedModel.getPrimaryKeyObj();
2246                    }
2247            }
2248    
2249            protected Element getDataElement(
2250                    Element parentElement, String attribute, String value) {
2251    
2252                    if (parentElement == null) {
2253                            return null;
2254                    }
2255    
2256                    StringBundler sb = new StringBundler(6);
2257    
2258                    sb.append("staged-model");
2259                    sb.append("[@");
2260                    sb.append(attribute);
2261                    sb.append("='");
2262                    sb.append(value);
2263                    sb.append("']");
2264    
2265                    XPath xPath = SAXReaderUtil.createXPath(sb.toString());
2266    
2267                    return (Element)xPath.selectSingleNode(parentElement);
2268            }
2269    
2270            protected String getExpandoPath(String path) {
2271                    return ExportImportPathUtil.getExpandoPath(path);
2272            }
2273    
2274            protected Element getExportDataGroupElement(String name) {
2275                    if (_exportDataRootElement == null) {
2276                            throw new IllegalStateException(
2277                                    "Root data element not initialized");
2278                    }
2279    
2280                    Element groupElement = _exportDataRootElement.element(name);
2281    
2282                    if (groupElement == null) {
2283                            groupElement = _exportDataRootElement.addElement(name);
2284                    }
2285    
2286                    return groupElement;
2287            }
2288    
2289            protected Element getImportDataGroupElement(String name) {
2290                    if (_importDataRootElement == null) {
2291                            throw new IllegalStateException(
2292                                    "Root data element not initialized");
2293                    }
2294    
2295                    if (Validator.isNull(name)) {
2296                            return SAXReaderUtil.createElement("EMPTY-ELEMENT");
2297                    }
2298    
2299                    Element groupElement = _importDataRootElement.element(name);
2300    
2301                    if (groupElement == null) {
2302                            return SAXReaderUtil.createElement("EMPTY-ELEMENT");
2303                    }
2304    
2305                    return groupElement;
2306            }
2307    
2308            protected Element getMissingReferenceElement(ClassedModel classedModel) {
2309                    StringBundler sb = new StringBundler(5);
2310    
2311                    sb.append("missing-reference[@class-name='");
2312                    sb.append(classedModel.getModelClassName());
2313                    sb.append("' and @class-pk='");
2314                    sb.append(String.valueOf(classedModel.getPrimaryKeyObj()));
2315                    sb.append("']");
2316    
2317                    XPath xPath = SAXReaderUtil.createXPath(sb.toString());
2318    
2319                    Node node = xPath.selectSingleNode(_missingReferencesElement);
2320    
2321                    return (Element)node;
2322            }
2323    
2324            protected String getPrimaryKeyString(Class<?> clazz, long classPK) {
2325                    return getPrimaryKeyString(clazz.getName(), String.valueOf(classPK));
2326            }
2327    
2328            protected String getPrimaryKeyString(Class<?> clazz, String primaryKey) {
2329                    return getPrimaryKeyString(clazz.getName(), primaryKey);
2330            }
2331    
2332            protected String getPrimaryKeyString(String className, long classPK) {
2333                    return getPrimaryKeyString(className, String.valueOf(classPK));
2334            }
2335    
2336            protected String getPrimaryKeyString(String className, String primaryKey) {
2337                    return className.concat(StringPool.POUND).concat(primaryKey);
2338            }
2339    
2340            protected List<Element> getReferenceDataElements(
2341                    List<Element> referenceElements, Class<?> clazz) {
2342    
2343                    List<Element> referenceDataElements = new ArrayList<Element>();
2344    
2345                    for (Element referenceElement : referenceElements) {
2346                            Element referenceDataElement = null;
2347    
2348                            String path = referenceElement.attributeValue("path");
2349    
2350                            if (Validator.isNotNull(path)) {
2351                                    referenceDataElement = getImportDataElement(
2352                                            clazz.getSimpleName(), "path", path);
2353                            }
2354                            else {
2355                                    String groupId = referenceElement.attributeValue("group-id");
2356                                    String uuid = referenceElement.attributeValue("uuid");
2357    
2358                                    StringBuilder sb = new StringBuilder(5);
2359    
2360                                    sb.append("staged-model[@uuid='");
2361                                    sb.append(uuid);
2362    
2363                                    if (groupId != null) {
2364                                            sb.append("' and @group-id='");
2365                                            sb.append(groupId);
2366                                    }
2367    
2368                                    sb.append("']");
2369    
2370                                    XPath xPath = SAXReaderUtil.createXPath(sb.toString());
2371    
2372                                    Element groupElement = getImportDataGroupElement(
2373                                            clazz.getSimpleName());
2374    
2375                                    referenceDataElement = (Element)xPath.selectSingleNode(
2376                                            groupElement);
2377                            }
2378    
2379                            if (referenceDataElement == null) {
2380                                    continue;
2381                            }
2382    
2383                            referenceDataElements.add(referenceDataElement);
2384                    }
2385    
2386                    return referenceDataElements;
2387            }
2388    
2389            protected List<Element> getReferenceElements(
2390                    Element parentElement, Class<?> clazz, long groupId, String uuid,
2391                    long classPK, String referenceType) {
2392    
2393                    if (parentElement == null) {
2394                            return Collections.emptyList();
2395                    }
2396    
2397                    Element referencesElement = parentElement.element("references");
2398    
2399                    if (referencesElement == null) {
2400                            return Collections.emptyList();
2401                    }
2402    
2403                    StringBundler sb = new StringBundler(5);
2404    
2405                    sb.append("reference[@class-name='");
2406                    sb.append(clazz.getName());
2407    
2408                    if (groupId > 0) {
2409                            sb.append("' and @group-id='");
2410                            sb.append(groupId);
2411                    }
2412    
2413                    if (Validator.isNotNull(uuid)) {
2414                            sb.append("' and @uuid='");
2415                            sb.append(uuid);
2416                    }
2417    
2418                    if (classPK > 0) {
2419                            sb.append("' and @class-pk='");
2420                            sb.append(classPK);
2421                    }
2422    
2423                    if (referenceType != null) {
2424                            sb.append("' and @type='");
2425                            sb.append(referenceType);
2426                    }
2427    
2428                    sb.append("']");
2429    
2430                    XPath xPath = SAXReaderUtil.createXPath(sb.toString());
2431    
2432                    List<Node> nodes = xPath.selectNodes(referencesElement);
2433    
2434                    return ListUtil.fromArray(nodes.toArray(new Element[nodes.size()]));
2435            }
2436    
2437            protected List<Element> getReferenceElements(
2438                    StagedModel parentStagedModel, Class<?> clazz, long classPK,
2439                    String referenceType) {
2440    
2441                    Element stagedModelElement = getImportDataStagedModelElement(
2442                            parentStagedModel);
2443    
2444                    return getReferenceElements(
2445                            stagedModelElement, clazz, 0, null, classPK, referenceType);
2446            }
2447    
2448            protected String getReferenceKey(ClassedModel classedModel) {
2449                    String referenceKey = classedModel.getModelClassName();
2450    
2451                    return referenceKey.concat(StringPool.POUND).concat(
2452                            String.valueOf(classedModel.getPrimaryKeyObj()));
2453            }
2454    
2455            protected long getUserId(AuditedModel auditedModel) {
2456                    try {
2457                            String userUuid = auditedModel.getUserUuid();
2458    
2459                            return getUserId(userUuid);
2460                    }
2461                    catch (SystemException se) {
2462                            if (_log.isErrorEnabled()) {
2463                                    _log.error(se, se);
2464                            }
2465                    }
2466    
2467                    return 0;
2468            }
2469    
2470            protected void initXStream() {
2471                    _xStream = new XStream();
2472    
2473                    _xStream.alias("BlogsEntry", BlogsEntryImpl.class);
2474                    _xStream.alias("BookmarksFolder", BookmarksFolderImpl.class);
2475                    _xStream.alias("BookmarksEntry", BookmarksEntryImpl.class);
2476                    _xStream.alias("DLFolder", DLFolderImpl.class);
2477                    _xStream.alias("DLFileEntry", DLFileEntryImpl.class);
2478                    _xStream.alias("DLFileShortcut", DLFileShortcutImpl.class);
2479                    _xStream.alias("JournalArticle", JournalArticleImpl.class);
2480                    _xStream.alias("JournalFeed", JournalFeedImpl.class);
2481                    _xStream.alias("Lock", LockImpl.class);
2482                    _xStream.alias("MBBan", MBBanImpl.class);
2483                    _xStream.alias("MBCategory", MBCategoryImpl.class);
2484                    _xStream.alias("MBMessage", MBMessageImpl.class);
2485                    _xStream.alias("MBThreadFlag", MBThreadFlagImpl.class);
2486                    _xStream.alias("PollsQuestion", PollsQuestionImpl.class);
2487                    _xStream.alias("PollsChoice", PollsChoiceImpl.class);
2488                    _xStream.alias("PollsVote", PollsVoteImpl.class);
2489                    _xStream.alias("RatingsEntry", RatingsEntryImpl.class);
2490                    _xStream.alias("WikiNode", WikiNodeImpl.class);
2491                    _xStream.alias("WikiPage", WikiPageImpl.class);
2492    
2493                    _xStream.omitField(HashMap.class, "cache_bitmask");
2494            }
2495    
2496            protected boolean isResourceMain(ClassedModel classedModel) {
2497                    if (classedModel instanceof ResourcedModel) {
2498                            ResourcedModel resourcedModel = (ResourcedModel)classedModel;
2499    
2500                            return resourcedModel.isResourceMain();
2501                    }
2502    
2503                    return true;
2504            }
2505    
2506            private static Log _log = LogFactoryUtil.getLog(
2507                    PortletDataContextImpl.class);
2508    
2509            private Map<String, long[]> _assetCategoryIdsMap =
2510                    new HashMap<String, long[]>();
2511            private Map<String, String[]> _assetCategoryUuidsMap =
2512                    new HashMap<String, String[]>();
2513            private Map<String, List<AssetLink>> _assetLinksMap =
2514                    new HashMap<String, List<AssetLink>>();
2515            private Map<String, String[]> _assetTagNamesMap =
2516                    new HashMap<String, String[]>();
2517            private Map<String, List<MBMessage>> _commentsMap =
2518                    new HashMap<String, List<MBMessage>>();
2519            private long _companyGroupId;
2520            private long _companyId;
2521            private String _dataStrategy;
2522            private Set<StagedModelType> _deletionSystemEventModelTypes =
2523                    new HashSet<StagedModelType>();
2524            private Date _endDate;
2525            private Map<String, List<ExpandoColumn>> _expandoColumnsMap =
2526                    new HashMap<String, List<ExpandoColumn>>();
2527            private Element _exportDataRootElement;
2528            private long _groupId;
2529            private Element _importDataRootElement;
2530            private Map<String, Lock> _locksMap = new HashMap<String, Lock>();
2531            private ManifestSummary _manifestSummary = new ManifestSummary();
2532            private Set<String> _missingReferences = new HashSet<String>();
2533            private Element _missingReferencesElement;
2534            private List<Layout> _newLayouts;
2535            private Map<String, Map<?, ?>> _newPrimaryKeysMaps =
2536                    new HashMap<String, Map<?, ?>>();
2537            private Set<String> _notUniquePerLayout = new HashSet<String>();
2538            private long _oldPlid;
2539            private Map<String, String[]> _parameterMap;
2540            private Map<String, List<KeyValuePair>> _permissionsMap =
2541                    new HashMap<String, List<KeyValuePair>>();
2542            private long _plid;
2543            private PortletDataContextListener _portletDataContextListener;
2544            private Set<String> _primaryKeys = new HashSet<String>();
2545            private boolean _privateLayout;
2546            private Map<String, List<RatingsEntry>> _ratingsEntriesMap =
2547                    new HashMap<String, List<RatingsEntry>>();
2548            private Set<String> _references = new HashSet<String>();
2549            private Set<String> _scopedPrimaryKeys = new HashSet<String>();
2550            private long _scopeGroupId;
2551            private String _scopeLayoutUuid;
2552            private String _scopeType;
2553            private long _sourceCompanyGroupId;
2554            private long _sourceCompanyId;
2555            private long _sourceGroupId;
2556            private long _sourceUserPersonalSiteGroupId;
2557            private Date _startDate;
2558            private UserIdStrategy _userIdStrategy;
2559            private long _userPersonalSiteGroupId;
2560            private XStream _xStream;
2561            private ZipReader _zipReader;
2562            private ZipWriter _zipWriter;
2563    
2564    }