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