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