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