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