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