001
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
119 public class PortletDataContextImpl implements PortletDataContext {
120
121 public PortletDataContextImpl() {
122 initXStream();
123 }
124
125
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
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
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
285 @Deprecated
286 @Override
287 public void addComments(Class<?> clazz, long classPK) {
288 }
289
290
295 @Deprecated
296 @Override
297 public void addComments(
298 String className, long classPK, List<MBMessage> messages) {
299 }
300
301
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
454 @Deprecated
455 @Override
456 public void addRatingsEntries(Class<?> clazz, long classPK) {
457 }
458
459
464 @Deprecated
465 @Override
466 public void addRatingsEntries(
467 String className, long classPK, List<RatingsEntry> ratingsEntries) {
468 }
469
470
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
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
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
714 @Deprecated
715 @Override
716 public Map<String, long[]> getAssetCategoryIdsMap() {
717 return Collections.emptyMap();
718 }
719
720
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
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
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
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
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
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
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
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
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
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
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
1273 @Deprecated
1274 @Override
1275 public String getSourceLayoutPath(long layoutId) {
1276 return StringPool.BLANK;
1277 }
1278
1279
1284 @Deprecated
1285 @Override
1286 public String getSourcePortletPath(String portletId) {
1287 return StringPool.BLANK;
1288 }
1289
1290
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
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
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
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
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
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
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
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
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
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
2006
2007 serviceContext.setCompanyId(getCompanyId());
2008 serviceContext.setScopeGroupId(getScopeGroupId());
2009
2010
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
2021
2022 if (!MapUtil.getBoolean(
2023 _parameterMap, PortletDataHandlerKeys.PERMISSIONS)) {
2024
2025 serviceContext.setAddGroupPermissions(true);
2026 serviceContext.setAddGuestPermissions(true);
2027 }
2028
2029
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
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 }