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