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