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