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