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