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