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