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