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<?, ?> getNewPrimaryKeysMap(String className) {
1081 Map<?, ?> map = _newPrimaryKeysMaps.get(className);
1082
1083 if (map == null) {
1084 map = new HashMap<Object, Object>();
1085
1086 _newPrimaryKeysMaps.put(className, map);
1087 }
1088
1089 return map;
1090 }
1091
1092 @Override
1093 public long getOldPlid() {
1094 return _oldPlid;
1095 }
1096
1097 @Override
1098 public Map<String, String[]> getParameterMap() {
1099 return _parameterMap;
1100 }
1101
1102 @Override
1103 public Map<String, List<KeyValuePair>> getPermissions() {
1104 return _permissionsMap;
1105 }
1106
1107 @Override
1108 public long getPlid() {
1109 return _plid;
1110 }
1111
1112 @Override
1113 public String getPortletPath(String portletId) {
1114 return ExportImportPathUtil.getPortletPath(this, portletId);
1115 }
1116
1117 @Override
1118 public Set<String> getPrimaryKeys() {
1119 return _primaryKeys;
1120 }
1121
1122 @Override
1123 public Map<String, List<RatingsEntry>> getRatingsEntries() {
1124 return _ratingsEntriesMap;
1125 }
1126
1127 @Override
1128 public Element getReferenceDataElement(
1129 Element parentElement, Class<?> clazz, long classPK) {
1130
1131 List<Element> referenceElements = getReferenceElements(
1132 parentElement, clazz, 0, null, classPK, null);
1133
1134 List<Element> referenceDataElements = getReferenceDataElements(
1135 referenceElements, clazz);
1136
1137 if (referenceDataElements.isEmpty()) {
1138 return null;
1139 }
1140
1141 return referenceDataElements.get(0);
1142 }
1143
1144 @Override
1145 public Element getReferenceDataElement(
1146 Element parentElement, Class<?> clazz, long groupId, String uuid) {
1147
1148 List<Element> referenceElements = getReferenceElements(
1149 parentElement, clazz, groupId, uuid, 0, null);
1150
1151 List<Element> referenceDataElements = getReferenceDataElements(
1152 referenceElements, clazz);
1153
1154 if (referenceDataElements.isEmpty()) {
1155 return null;
1156 }
1157
1158 return referenceDataElements.get(0);
1159 }
1160
1161 @Override
1162 public Element getReferenceDataElement(
1163 StagedModel parentStagedModel, Class<?> clazz, long classPK) {
1164
1165 Element parentElement = getImportDataStagedModelElement(
1166 parentStagedModel);
1167
1168 return getReferenceDataElement(parentElement, clazz, classPK);
1169 }
1170
1171 @Override
1172 public Element getReferenceDataElement(
1173 StagedModel parentStagedModel, Class<?> clazz, long groupId,
1174 String uuid) {
1175
1176 Element parentElement = getImportDataStagedModelElement(
1177 parentStagedModel);
1178
1179 return getReferenceDataElement(parentElement, clazz, groupId, uuid);
1180 }
1181
1182 @Override
1183 public List<Element> getReferenceDataElements(
1184 Element parentElement, Class<?> clazz) {
1185
1186 return getReferenceDataElements(parentElement, clazz, null);
1187 }
1188
1189 @Override
1190 public List<Element> getReferenceDataElements(
1191 Element parentElement, Class<?> clazz, String referenceType) {
1192
1193 List<Element> referenceElements = getReferenceElements(
1194 parentElement, clazz, 0, null, 0, referenceType);
1195
1196 return getReferenceDataElements(referenceElements, clazz);
1197 }
1198
1199 @Override
1200 public List<Element> getReferenceDataElements(
1201 StagedModel parentStagedModel, Class<?> clazz) {
1202
1203 return getReferenceDataElements(parentStagedModel, clazz, null);
1204 }
1205
1206 @Override
1207 public List<Element> getReferenceDataElements(
1208 StagedModel parentStagedModel, Class<?> clazz, String referenceType) {
1209
1210 List<Element> referenceElements = getReferenceElements(
1211 parentStagedModel, clazz, 0, referenceType);
1212
1213 return getReferenceDataElements(referenceElements, clazz);
1214 }
1215
1216 @Override
1217 public Element getReferenceElement(
1218 StagedModel parentStagedModel, Class<?> clazz, long classPK) {
1219
1220 List<Element> referenceElements = getReferenceElements(
1221 parentStagedModel, clazz, classPK, null);
1222
1223 if (!referenceElements.isEmpty()) {
1224 return referenceElements.get(0);
1225 }
1226
1227 return null;
1228 }
1229
1230 @Override
1231 public List<Element> getReferenceElements(
1232 StagedModel parentStagedModel, Class<?> clazz) {
1233
1234 return getReferenceElements(parentStagedModel, clazz, 0, null);
1235 }
1236
1237 @Override
1238 public String getRootPath() {
1239 return ExportImportPathUtil.getRootPath(this);
1240 }
1241
1242 @Override
1243 public Set<String> getScopedPrimaryKeys() {
1244 return _scopedPrimaryKeys;
1245 }
1246
1247 @Override
1248 public long getScopeGroupId() {
1249 return _scopeGroupId;
1250 }
1251
1252 @Override
1253 public String getScopeLayoutUuid() {
1254 return _scopeLayoutUuid;
1255 }
1256
1257 @Override
1258 public String getScopeType() {
1259 return _scopeType;
1260 }
1261
1262 @Override
1263 public long getSourceCompanyGroupId() {
1264 return _sourceCompanyGroupId;
1265 }
1266
1267 @Override
1268 public long getSourceCompanyId() {
1269 return _sourceCompanyId;
1270 }
1271
1272 @Override
1273 public long getSourceGroupId() {
1274 return _sourceGroupId;
1275 }
1276
1277 @Override
1278 public String getSourceLayoutPath(long layoutId) {
1279 return ExportImportPathUtil.getSourceLayoutPath(this, layoutId);
1280 }
1281
1282 @Override
1283 public String getSourcePortletPath(String portletId) {
1284 return ExportImportPathUtil.getSourcePortletPath(this, portletId);
1285 }
1286
1287 @Override
1288 public String getSourceRootPath() {
1289 return ExportImportPathUtil.getSourceRootPath(this);
1290 }
1291
1292 @Override
1293 public long getSourceUserPersonalSiteGroupId() {
1294 return _sourceUserPersonalSiteGroupId;
1295 }
1296
1297 @Override
1298 public Date getStartDate() {
1299 return _startDate;
1300 }
1301
1302 @Override
1303 public long getUserId(String userUuid) {
1304 return _userIdStrategy.getUserId(userUuid);
1305 }
1306
1307 @Override
1308 public UserIdStrategy getUserIdStrategy() {
1309 return _userIdStrategy;
1310 }
1311
1312 @Override
1313 public long getUserPersonalSiteGroupId() {
1314 return _userPersonalSiteGroupId;
1315 }
1316
1317 @Override
1318 public List<String> getZipEntries() {
1319 return getZipReader().getEntries();
1320 }
1321
1322 @Override
1323 public byte[] getZipEntryAsByteArray(String path) {
1324 if (!Validator.isFilePath(path, false)) {
1325 return null;
1326 }
1327
1328 if (_portletDataContextListener != null) {
1329 _portletDataContextListener.onGetZipEntry(path);
1330 }
1331
1332 return getZipReader().getEntryAsByteArray(path);
1333 }
1334
1335 @Override
1336 public InputStream getZipEntryAsInputStream(String path) {
1337 if (!Validator.isFilePath(path, false)) {
1338 return null;
1339 }
1340
1341 if (_portletDataContextListener != null) {
1342 _portletDataContextListener.onGetZipEntry(path);
1343 }
1344
1345 return getZipReader().getEntryAsInputStream(path);
1346 }
1347
1348 @Override
1349 public Object getZipEntryAsObject(Element element, String path) {
1350 Object object = fromXML(getZipEntryAsString(path));
1351
1352 Attribute classNameAttribute = element.attribute("class-name");
1353
1354 if (classNameAttribute != null) {
1355 BeanPropertiesUtil.setProperty(
1356 object, "className", classNameAttribute.getText());
1357 }
1358
1359 return object;
1360 }
1361
1362 @Override
1363 public Object getZipEntryAsObject(String path) {
1364 return fromXML(getZipEntryAsString(path));
1365 }
1366
1367 @Override
1368 public String getZipEntryAsString(String path) {
1369 if (!Validator.isFilePath(path, false)) {
1370 return null;
1371 }
1372
1373 if (_portletDataContextListener != null) {
1374 _portletDataContextListener.onGetZipEntry(path);
1375 }
1376
1377 return getZipReader().getEntryAsString(path);
1378 }
1379
1380 @Override
1381 public List<String> getZipFolderEntries() {
1382 return getZipFolderEntries(StringPool.SLASH);
1383 }
1384
1385 @Override
1386 public List<String> getZipFolderEntries(String path) {
1387 if (!Validator.isFilePath(path, false)) {
1388 return null;
1389 }
1390
1391 return getZipReader().getFolderEntries(path);
1392 }
1393
1394 @Override
1395 public ZipReader getZipReader() {
1396 return _zipReader;
1397 }
1398
1399 @Override
1400 public ZipWriter getZipWriter() {
1401 return _zipWriter;
1402 }
1403
1404 @Override
1405 public boolean hasDateRange() {
1406 if (_startDate != null) {
1407 return true;
1408 }
1409 else {
1410 return false;
1411 }
1412 }
1413
1414 @Override
1415 public boolean hasNotUniquePerLayout(String dataKey) {
1416 return _notUniquePerLayout.contains(dataKey);
1417 }
1418
1419 @Override
1420 public boolean hasPrimaryKey(Class<?> clazz, String primaryKey) {
1421 return _primaryKeys.contains(getPrimaryKeyString(clazz, primaryKey));
1422 }
1423
1424 @Override
1425 public boolean hasScopedPrimaryKey(Class<?> clazz, String primaryKey) {
1426 return _scopedPrimaryKeys.contains(
1427 getPrimaryKeyString(clazz, primaryKey));
1428 }
1429
1430 @Override
1431 public void importClassedModel(
1432 ClassedModel classedModel, ClassedModel newClassedModel)
1433 throws PortalException, SystemException {
1434
1435 importClassedModel(
1436 classedModel, newClassedModel, classedModel.getModelClass());
1437 }
1438
1439 @Override
1440 public void importClassedModel(
1441 ClassedModel classedModel, ClassedModel newClassedModel,
1442 Class<?> clazz)
1443 throws PortalException, SystemException {
1444
1445 if (!isResourceMain(classedModel)) {
1446 return;
1447 }
1448
1449 long classPK = getClassPK(classedModel);
1450
1451 long newClassPK = getClassPK(newClassedModel);
1452
1453 Map<Long, Long> newPrimaryKeysMap =
1454 (Map<Long, Long>)getNewPrimaryKeysMap(clazz);
1455
1456 newPrimaryKeysMap.put(classPK, newClassPK);
1457
1458 importLocks(clazz, String.valueOf(classPK), String.valueOf(newClassPK));
1459 importPermissions(clazz, classPK, newClassPK);
1460
1461 boolean portletDataAll = MapUtil.getBoolean(
1462 getParameterMap(), PortletDataHandlerKeys.PORTLET_DATA_ALL);
1463
1464 if (portletDataAll ||
1465 MapUtil.getBoolean(
1466 getParameterMap(), PortletDataHandlerKeys.COMMENTS)) {
1467
1468 importComments(clazz, classPK, newClassPK, getScopeGroupId());
1469 }
1470
1471 if (portletDataAll ||
1472 MapUtil.getBoolean(
1473 getParameterMap(), PortletDataHandlerKeys.RATINGS)) {
1474
1475 importRatingsEntries(clazz, classPK, newClassPK);
1476 }
1477 }
1478
1479
1483 @Override
1484 public void importClassedModel(
1485 ClassedModel classedModel, ClassedModel newClassedModel,
1486 Class<?> clazz, String namespace)
1487 throws PortalException, SystemException {
1488
1489 importClassedModel(classedModel, newClassedModel, clazz);
1490 }
1491
1492
1496 @Override
1497 public void importClassedModel(
1498 ClassedModel classedModel, ClassedModel newClassedModel,
1499 String namespace)
1500 throws PortalException, SystemException {
1501
1502 importClassedModel(
1503 classedModel, newClassedModel, classedModel.getModelClass());
1504 }
1505
1506 @Override
1507 public void importComments(
1508 Class<?> clazz, long classPK, long newClassPK, long groupId)
1509 throws PortalException, SystemException {
1510
1511 Map<Long, Long> messagePKs = new HashMap<Long, Long>();
1512 Map<Long, Long> threadPKs = new HashMap<Long, Long>();
1513
1514 List<MBMessage> messages = _commentsMap.get(
1515 getPrimaryKeyString(clazz, classPK));
1516
1517 if (messages == null) {
1518 return;
1519 }
1520
1521 MBMessage firstMessage = messages.get(0);
1522
1523 if ((messages.size() == 1) && firstMessage.isRoot()) {
1524 return;
1525 }
1526
1527 long classNameId = PortalUtil.getClassNameId(clazz);
1528
1529 MBDiscussion discussion = MBDiscussionUtil.fetchByC_C(
1530 classNameId, newClassPK);
1531
1532 for (MBMessage message : messages) {
1533 long userId = getUserId(message.getUserUuid());
1534 long parentMessageId = MapUtil.getLong(
1535 messagePKs, message.getParentMessageId(),
1536 message.getParentMessageId());
1537 long threadId = MapUtil.getLong(
1538 threadPKs, message.getThreadId(), message.getThreadId());
1539
1540 if (message.isRoot()) {
1541 if (discussion != null) {
1542 MBThread thread = MBThreadLocalServiceUtil.getThread(
1543 discussion.getThreadId());
1544
1545 long rootMessageId = thread.getRootMessageId();
1546
1547 messagePKs.put(message.getMessageId(), rootMessageId);
1548 threadPKs.put(message.getThreadId(), thread.getThreadId());
1549 }
1550 else if (clazz == Layout.class) {
1551 MBMessage importedMessage =
1552 MBMessageLocalServiceUtil.addDiscussionMessage(
1553 userId, message.getUserName(), groupId,
1554 clazz.getName(), newClassPK,
1555 WorkflowConstants.ACTION_PUBLISH);
1556
1557 messagePKs.put(
1558 message.getMessageId(), importedMessage.getMessageId());
1559 threadPKs.put(
1560 message.getThreadId(), importedMessage.getThreadId());
1561 }
1562 }
1563 else {
1564 ServiceContext serviceContext = new ServiceContext();
1565
1566 serviceContext.setCreateDate(message.getCreateDate());
1567 serviceContext.setModifiedDate(message.getModifiedDate());
1568 serviceContext.setScopeGroupId(groupId);
1569
1570 MBMessage importedMessage = null;
1571
1572 if (_dataStrategy.equals(
1573 PortletDataHandlerKeys.DATA_STRATEGY_MIRROR) ||
1574 _dataStrategy.equals(
1575 PortletDataHandlerKeys.
1576 DATA_STRATEGY_MIRROR_OVERWRITE)) {
1577
1578 MBMessage existingMessage = MBMessageUtil.fetchByUUID_G(
1579 message.getUuid(), groupId);
1580
1581 if (existingMessage == null) {
1582 serviceContext.setUuid(message.getUuid());
1583
1584 importedMessage =
1585 MBMessageLocalServiceUtil.addDiscussionMessage(
1586 userId, message.getUserName(), groupId,
1587 clazz.getName(), newClassPK, threadId,
1588 parentMessageId, message.getSubject(),
1589 message.getBody(), serviceContext);
1590 }
1591 else {
1592 serviceContext.setWorkflowAction(
1593 WorkflowConstants.ACTION_PUBLISH);
1594
1595 importedMessage =
1596 MBMessageLocalServiceUtil.updateDiscussionMessage(
1597 userId, existingMessage.getMessageId(),
1598 clazz.getName(), newClassPK,
1599 message.getSubject(), message.getBody(),
1600 serviceContext);
1601 }
1602 }
1603 else {
1604 importedMessage =
1605 MBMessageLocalServiceUtil.addDiscussionMessage(
1606 userId, message.getUserName(), groupId,
1607 clazz.getName(), newClassPK, threadId,
1608 parentMessageId, message.getSubject(),
1609 message.getBody(), serviceContext);
1610 }
1611
1612 messagePKs.put(
1613 message.getMessageId(), importedMessage.getMessageId());
1614 threadPKs.put(
1615 message.getThreadId(), importedMessage.getThreadId());
1616 }
1617
1618 importRatingsEntries(
1619 MBDiscussion.class, message.getPrimaryKey(),
1620 messagePKs.get(message.getPrimaryKey()));
1621 }
1622 }
1623
1624 @Override
1625 public void importLocks(Class<?> clazz, String key, String newKey)
1626 throws PortalException, SystemException {
1627
1628 Lock lock = _locksMap.get(getPrimaryKeyString(clazz, key));
1629
1630 if (lock == null) {
1631 return;
1632 }
1633
1634 long userId = getUserId(lock.getUserUuid());
1635
1636 long expirationTime = 0;
1637
1638 if (lock.getExpirationDate() != null) {
1639 Date expirationDate = lock.getExpirationDate();
1640
1641 expirationTime = expirationDate.getTime();
1642 }
1643
1644 LockLocalServiceUtil.lock(
1645 userId, clazz.getName(), newKey, lock.getOwner(),
1646 lock.isInheritable(), expirationTime);
1647 }
1648
1649 @Override
1650 public void importPermissions(Class<?> clazz, long classPK, long newClassPK)
1651 throws PortalException, SystemException {
1652
1653 importPermissions(clazz.getName(), classPK, newClassPK);
1654 }
1655
1656 @Override
1657 public void importPermissions(
1658 String resourceName, long resourcePK, long newResourcePK)
1659 throws PortalException, SystemException {
1660
1661 if (!MapUtil.getBoolean(
1662 _parameterMap, PortletDataHandlerKeys.PERMISSIONS)) {
1663
1664 return;
1665 }
1666
1667 List<KeyValuePair> permissions = _permissionsMap.get(
1668 getPrimaryKeyString(resourceName, resourcePK));
1669
1670 if (permissions == null) {
1671 return;
1672 }
1673
1674 Map<Long, String[]> roleIdsToActionIds = new HashMap<Long, String[]>();
1675
1676 for (KeyValuePair permission : permissions) {
1677 String roleName = permission.getKey();
1678
1679 Role role = null;
1680
1681 Team team = null;
1682
1683 if (roleName.startsWith(PermissionExporter.ROLE_TEAM_PREFIX)) {
1684 roleName = roleName.substring(
1685 PermissionExporter.ROLE_TEAM_PREFIX.length());
1686
1687 try {
1688 team = TeamLocalServiceUtil.getTeam(_groupId, roleName);
1689 }
1690 catch (NoSuchTeamException nste) {
1691 if (_log.isWarnEnabled()) {
1692 _log.warn("Team " + roleName + " does not exist");
1693 }
1694
1695 continue;
1696 }
1697 }
1698
1699 try {
1700 if (team != null) {
1701 role = RoleLocalServiceUtil.getTeamRole(
1702 _companyId, team.getTeamId());
1703 }
1704 else {
1705 role = RoleLocalServiceUtil.getRole(_companyId, roleName);
1706 }
1707 }
1708 catch (NoSuchRoleException nsre) {
1709 if (_log.isWarnEnabled()) {
1710 _log.warn("Role " + roleName + " does not exist");
1711 }
1712
1713 continue;
1714 }
1715
1716 String[] actionIds = StringUtil.split(permission.getValue());
1717
1718 roleIdsToActionIds.put(role.getRoleId(), actionIds);
1719 }
1720
1721 if (roleIdsToActionIds.isEmpty()) {
1722 return;
1723 }
1724
1725 if (ResourceBlockLocalServiceUtil.isSupported(resourceName)) {
1726 ResourceBlockLocalServiceUtil.setIndividualScopePermissions(
1727 _companyId, _groupId, resourceName, newResourcePK,
1728 roleIdsToActionIds);
1729 }
1730 else {
1731 ResourcePermissionLocalServiceUtil.setResourcePermissions(
1732 _companyId, resourceName, ResourceConstants.SCOPE_INDIVIDUAL,
1733 String.valueOf(newResourcePK), roleIdsToActionIds);
1734 }
1735 }
1736
1737 @Override
1738 public void importPortalPermissions()
1739 throws PortalException, SystemException {
1740
1741 importPermissions(
1742 PortletKeys.PORTAL, getSourceCompanyId(), getCompanyId());
1743 }
1744
1745 @Override
1746 public void importPortletPermissions(String resourceName)
1747 throws PortalException, SystemException {
1748
1749 importPermissions(resourceName, getSourceGroupId(), getScopeGroupId());
1750 }
1751
1752 @Override
1753 public void importRatingsEntries(
1754 Class<?> clazz, long classPK, long newClassPK)
1755 throws PortalException, SystemException {
1756
1757 List<RatingsEntry> ratingsEntries = _ratingsEntriesMap.get(
1758 getPrimaryKeyString(clazz, classPK));
1759
1760 if (ratingsEntries == null) {
1761 return;
1762 }
1763
1764 ServiceContext serviceContext = new ServiceContext();
1765
1766 for (RatingsEntry ratingsEntry : ratingsEntries) {
1767 long userId = getUserId(ratingsEntry.getUserUuid());
1768
1769 serviceContext.setCreateDate(ratingsEntry.getCreateDate());
1770 serviceContext.setModifiedDate(ratingsEntry.getModifiedDate());
1771
1772 RatingsEntryLocalServiceUtil.updateEntry(
1773 userId, clazz.getName(), newClassPK, ratingsEntry.getScore(),
1774 serviceContext);
1775 }
1776 }
1777
1778 @Override
1779 public boolean isCompanyStagedGroupedModel(
1780 StagedGroupedModel stagedGroupedModel) {
1781
1782 if ((stagedGroupedModel.getGroupId() == getCompanyGroupId()) &&
1783 (getGroupId() != getCompanyGroupId())) {
1784
1785 return true;
1786 }
1787
1788 return false;
1789 }
1790
1791 @Override
1792 public boolean isDataStrategyMirror() {
1793 if (_dataStrategy.equals(PortletDataHandlerKeys.DATA_STRATEGY_MIRROR) ||
1794 _dataStrategy.equals(
1795 PortletDataHandlerKeys.DATA_STRATEGY_MIRROR_OVERWRITE)) {
1796
1797 return true;
1798 }
1799 else {
1800 return false;
1801 }
1802 }
1803
1804 @Override
1805 public boolean isDataStrategyMirrorWithOverwriting() {
1806 if (_dataStrategy.equals(
1807 PortletDataHandlerKeys.DATA_STRATEGY_MIRROR_OVERWRITE)) {
1808
1809 return true;
1810 }
1811 else {
1812 return false;
1813 }
1814 }
1815
1816 @Override
1817 public boolean isMissingReference(Element referenceElement) {
1818 Attribute missingAttribute = referenceElement.attribute("missing");
1819
1820 if ((missingAttribute != null) &&
1821 !GetterUtil.getBoolean(
1822 referenceElement.attributeValue("missing"))) {
1823
1824 return false;
1825 }
1826
1827 if (_missingReferences.isEmpty()) {
1828 List<Element> missingReferenceElements =
1829 _missingReferencesElement.elements();
1830
1831 for (Element missingReferenceElement : missingReferenceElements) {
1832 String missingReferenceClassName =
1833 missingReferenceElement.attributeValue("class-name");
1834 String missingReferenceClassPK =
1835 missingReferenceElement.attributeValue("class-pk");
1836
1837 String missingReferenceKey = getReferenceKey(
1838 missingReferenceClassName, missingReferenceClassPK);
1839
1840 _missingReferences.add(missingReferenceKey);
1841 }
1842 }
1843
1844 String className = referenceElement.attributeValue("class-name");
1845 String classPK = referenceElement.attributeValue("class-pk");
1846
1847 String referenceKey = getReferenceKey(className, classPK);
1848
1849 return _missingReferences.contains(referenceKey);
1850 }
1851
1852 @Override
1853 public boolean isModelCounted(String className, long classPK) {
1854 String modelCountedPrimaryKey = className.concat(
1855 StringPool.POUND).concat(String.valueOf(classPK));
1856
1857 return addPrimaryKey(String.class, modelCountedPrimaryKey);
1858 }
1859
1860 @Override
1861 public boolean isPathExportedInScope(String path) {
1862 return addScopedPrimaryKey(String.class, path);
1863 }
1864
1865 @Override
1866 public boolean isPathNotExportedInScope(String path) {
1867 return !isPathExportedInScope(path);
1868 }
1869
1870 @Override
1871 public boolean isPathNotProcessed(String path) {
1872 return !isPathProcessed(path);
1873 }
1874
1875 @Override
1876 public boolean isPathProcessed(String path) {
1877 addScopedPrimaryKey(String.class, path);
1878
1879 return addPrimaryKey(String.class, path);
1880 }
1881
1882 @Override
1883 public boolean isPerformDirectBinaryImport() {
1884 return MapUtil.getBoolean(
1885 _parameterMap, PortletDataHandlerKeys.PERFORM_DIRECT_BINARY_IMPORT);
1886 }
1887
1888 @Override
1889 public boolean isPrivateLayout() {
1890 return _privateLayout;
1891 }
1892
1893 @Override
1894 public boolean isStagedModelCounted(StagedModel stagedModel) {
1895 StagedModelType stagedModelType = stagedModel.getStagedModelType();
1896
1897 return isModelCounted(
1898 stagedModelType.getClassName(),
1899 (Long)stagedModel.getPrimaryKeyObj());
1900 }
1901
1902
1905 @Override
1906 public boolean isWithinDateRange(Date modifiedDate) {
1907 if (!hasDateRange()) {
1908 return true;
1909 }
1910 else if ((_startDate.compareTo(modifiedDate) <= 0) &&
1911 _endDate.after(modifiedDate)) {
1912
1913 return true;
1914 }
1915 else {
1916 return false;
1917 }
1918 }
1919
1920 @Override
1921 public void putNotUniquePerLayout(String dataKey) {
1922 _notUniquePerLayout.add(dataKey);
1923 }
1924
1925 @Override
1926 public void setClassLoader(ClassLoader classLoader) {
1927 _xStream.setClassLoader(classLoader);
1928 }
1929
1930 @Override
1931 public void setCompanyGroupId(long companyGroupId) {
1932 _companyGroupId = companyGroupId;
1933 }
1934
1935 @Override
1936 public void setCompanyId(long companyId) {
1937 _companyId = companyId;
1938 }
1939
1940 @Override
1941 public void setDataStrategy(String dataStrategy) {
1942 _dataStrategy = dataStrategy;
1943 }
1944
1945 @Override
1946 public void setEndDate(Date endDate) {
1947 _endDate = endDate;
1948 }
1949
1950 @Override
1951 public void setExportDataRootElement(Element exportDataRootElement) {
1952 _exportDataRootElement = exportDataRootElement;
1953 }
1954
1955 @Override
1956 public void setGroupId(long groupId) {
1957 _groupId = groupId;
1958 }
1959
1960 @Override
1961 public void setImportDataRootElement(Element importDataRootElement) {
1962 _importDataRootElement = importDataRootElement;
1963 }
1964
1965 @Override
1966 public void setManifestSummary(ManifestSummary manifestSummary) {
1967 _manifestSummary = manifestSummary;
1968 }
1969
1970 @Override
1971 public void setMissingReferencesElement(Element missingReferencesElement) {
1972 _missingReferencesElement = missingReferencesElement;
1973 }
1974
1975 @Override
1976 public void setNewLayouts(List<Layout> newLayouts) {
1977 _newLayouts = newLayouts;
1978 }
1979
1980 @Override
1981 public void setOldPlid(long oldPlid) {
1982 _oldPlid = oldPlid;
1983 }
1984
1985 @Override
1986 public void setParameterMap(Map<String, String[]> parameterMap) {
1987 _parameterMap = parameterMap;
1988 }
1989
1990 @Override
1991 public void setPlid(long plid) {
1992 _plid = plid;
1993 }
1994
1995 @Override
1996 public void setPortetDataContextListener(
1997 PortletDataContextListener portletDataContextListener) {
1998
1999 _portletDataContextListener = portletDataContextListener;
2000 }
2001
2002 @Override
2003 public void setPrivateLayout(boolean privateLayout) {
2004 _privateLayout = privateLayout;
2005 }
2006
2007 @Override
2008 public void setScopeGroupId(long scopeGroupId) {
2009 _scopeGroupId = scopeGroupId;
2010 }
2011
2012 @Override
2013 public void setScopeLayoutUuid(String scopeLayoutUuid) {
2014 _scopeLayoutUuid = scopeLayoutUuid;
2015 }
2016
2017 @Override
2018 public void setScopeType(String scopeType) {
2019 _scopeType = scopeType;
2020 }
2021
2022 @Override
2023 public void setSourceCompanyGroupId(long sourceCompanyGroupId) {
2024 _sourceCompanyGroupId = sourceCompanyGroupId;
2025 }
2026
2027 @Override
2028 public void setSourceCompanyId(long sourceCompanyId) {
2029 _sourceCompanyId = sourceCompanyId;
2030 }
2031
2032 @Override
2033 public void setSourceGroupId(long sourceGroupId) {
2034 _sourceGroupId = sourceGroupId;
2035 }
2036
2037 @Override
2038 public void setSourceUserPersonalSiteGroupId(
2039 long sourceUserPersonalSiteGroupId) {
2040
2041 _sourceUserPersonalSiteGroupId = sourceUserPersonalSiteGroupId;
2042 }
2043
2044 @Override
2045 public void setStartDate(Date startDate) {
2046 _startDate = startDate;
2047 }
2048
2049 @Override
2050 public void setUserIdStrategy(UserIdStrategy userIdStrategy) {
2051 _userIdStrategy = userIdStrategy;
2052 }
2053
2054 @Override
2055 public void setUserPersonalSiteGroupId(long userPersonalSiteGroupId) {
2056 _userPersonalSiteGroupId = userPersonalSiteGroupId;
2057 }
2058
2059 @Override
2060 public void setZipReader(ZipReader zipReader) {
2061 _zipReader = zipReader;
2062 }
2063
2064 @Override
2065 public void setZipWriter(ZipWriter zipWriter) {
2066 _zipWriter = zipWriter;
2067 }
2068
2069 @Override
2070 public String toXML(Object object) {
2071 return _xStream.toXML(object);
2072 }
2073
2074 protected void addExpando(
2075 Element element, String path, ClassedModel classedModel,
2076 Class<?> clazz)
2077 throws PortalException, SystemException {
2078
2079 String className = clazz.getName();
2080
2081 if (!_expandoColumnsMap.containsKey(className)) {
2082 List<ExpandoColumn> expandoColumns =
2083 ExpandoColumnLocalServiceUtil.getDefaultTableColumns(
2084 _companyId, className);
2085
2086 for (ExpandoColumn expandoColumn : expandoColumns) {
2087 addPermissions(
2088 ExpandoColumn.class, expandoColumn.getColumnId());
2089 }
2090
2091 _expandoColumnsMap.put(className, expandoColumns);
2092 }
2093
2094 ExpandoBridge expandoBridge = classedModel.getExpandoBridge();
2095
2096 Map<String, Serializable> expandoBridgeAttributes =
2097 expandoBridge.getAttributes();
2098
2099 if (!expandoBridgeAttributes.isEmpty()) {
2100 String expandoPath = ExportImportPathUtil.getExpandoPath(path);
2101
2102 element.addAttribute("expando-path", expandoPath);
2103
2104 addZipEntry(expandoPath, expandoBridgeAttributes);
2105 }
2106 }
2107
2108 protected ServiceContext createServiceContext(
2109 Element element, String path, ClassedModel classedModel,
2110 Class<?> clazz) {
2111
2112 long classPK = getClassPK(classedModel);
2113
2114 ServiceContext serviceContext = new ServiceContext();
2115
2116
2117
2118 serviceContext.setCompanyId(getCompanyId());
2119 serviceContext.setScopeGroupId(getScopeGroupId());
2120
2121
2122
2123 if (classedModel instanceof AuditedModel) {
2124 AuditedModel auditedModel = (AuditedModel)classedModel;
2125
2126 serviceContext.setUserId(getUserId(auditedModel));
2127 serviceContext.setCreateDate(auditedModel.getCreateDate());
2128 serviceContext.setModifiedDate(auditedModel.getModifiedDate());
2129 }
2130
2131
2132
2133 if (!MapUtil.getBoolean(
2134 _parameterMap, PortletDataHandlerKeys.PERMISSIONS)) {
2135
2136 serviceContext.setAddGroupPermissions(true);
2137 serviceContext.setAddGuestPermissions(true);
2138 }
2139
2140
2141
2142 if (isResourceMain(classedModel)) {
2143 long[] assetCategoryIds = getAssetCategoryIds(clazz, classPK);
2144
2145 serviceContext.setAssetCategoryIds(assetCategoryIds);
2146
2147 String[] assetTagNames = getAssetTagNames(clazz, classPK);
2148
2149 serviceContext.setAssetTagNames(assetTagNames);
2150 }
2151
2152
2153
2154 String expandoPath = null;
2155
2156 if (element != null) {
2157 expandoPath = element.attributeValue("expando-path");
2158 }
2159 else {
2160 expandoPath = ExportImportPathUtil.getExpandoPath(path);
2161 }
2162
2163 if (Validator.isNotNull(expandoPath)) {
2164 try {
2165 Map<String, Serializable> expandoBridgeAttributes =
2166 (Map<String, Serializable>)getZipEntryAsObject(expandoPath);
2167
2168 if (expandoBridgeAttributes != null) {
2169 serviceContext.setExpandoBridgeAttributes(
2170 expandoBridgeAttributes);
2171 }
2172 }
2173 catch (Exception e) {
2174 if (_log.isDebugEnabled()) {
2175 _log.debug(e, e);
2176 }
2177 }
2178 }
2179
2180 return serviceContext;
2181 }
2182
2183 protected Element doAddReferenceElement(
2184 ClassedModel referrerClassedModel, Element element,
2185 ClassedModel classedModel, String className, String binPath,
2186 String referenceType, boolean missing) {
2187
2188 Element referenceElement = null;
2189
2190 if (missing) {
2191 Element referencesElement = _missingReferencesElement;
2192
2193 referenceElement = referencesElement.addElement(
2194 "missing-reference");
2195 }
2196 else {
2197 Element referencesElement = element.element("references");
2198
2199 if (referencesElement == null) {
2200 referencesElement = element.addElement("references");
2201 }
2202
2203 referenceElement = referencesElement.addElement("reference");
2204 }
2205
2206 referenceElement.addAttribute("class-name", className);
2207
2208 referenceElement.addAttribute(
2209 "class-pk", String.valueOf(classedModel.getPrimaryKeyObj()));
2210
2211 if (missing) {
2212 if (classedModel instanceof StagedModel) {
2213 referenceElement.addAttribute(
2214 "display-name",
2215 StagedModelDataHandlerUtil.getDisplayName(
2216 (StagedModel)classedModel));
2217 }
2218 else {
2219 referenceElement.addAttribute(
2220 "display-name",
2221 String.valueOf(classedModel.getPrimaryKeyObj()));
2222 }
2223 }
2224
2225 if (classedModel instanceof StagedGroupedModel) {
2226 StagedGroupedModel stagedGroupedModel =
2227 (StagedGroupedModel)classedModel;
2228
2229 referenceElement.addAttribute(
2230 "group-id", String.valueOf(stagedGroupedModel.getGroupId()));
2231 }
2232
2233 if (Validator.isNotNull(binPath)) {
2234 referenceElement.addAttribute("path", binPath);
2235 }
2236
2237 referenceElement.addAttribute("type", referenceType);
2238
2239 if (missing) {
2240 referenceElement.addAttribute(
2241 "referrer-class-name",
2242 ExportImportClassedModelUtil.getClassName(
2243 referrerClassedModel));
2244
2245 if (referrerClassedModel instanceof PortletModel) {
2246 Portlet portlet = (Portlet)referrerClassedModel;
2247
2248 referenceElement.addAttribute(
2249 "referrer-display-name", portlet.getRootPortletId());
2250 }
2251 else if (referrerClassedModel instanceof StagedModel) {
2252 StagedModel referrerStagedModel =
2253 (StagedModel)referrerClassedModel;
2254
2255 referenceElement.addAttribute(
2256 "referrer-display-name",
2257 StagedModelDataHandlerUtil.getDisplayName(
2258 referrerStagedModel));
2259 }
2260 }
2261
2262 if (classedModel instanceof StagedModel) {
2263 StagedModel stagedModel = (StagedModel)classedModel;
2264
2265 referenceElement.addAttribute("uuid", stagedModel.getUuid());
2266 referenceElement.addAttribute(
2267 "company-id", String.valueOf(stagedModel.getCompanyId()));
2268
2269 Map<String, String> referenceAttributes =
2270 StagedModelDataHandlerUtil.getReferenceAttributes(
2271 this, stagedModel);
2272
2273 for (Map.Entry<String, String> referenceAttribute :
2274 referenceAttributes.entrySet()) {
2275
2276 referenceElement.addAttribute(
2277 referenceAttribute.getKey(), referenceAttribute.getValue());
2278 }
2279 }
2280
2281 return referenceElement;
2282 }
2283
2284 protected Map<Long, Set<String>> getActionIds(
2285 long companyId, long[] roleIds, String className, long primKey,
2286 List<String> actionIds)
2287 throws PortalException, SystemException {
2288
2289 if (ResourceBlockLocalServiceUtil.isSupported(className)) {
2290 return ResourceBlockPermissionLocalServiceUtil.
2291 getAvailableResourceBlockPermissionActionIds(
2292 roleIds, className, primKey, actionIds);
2293 }
2294 else {
2295 return ResourcePermissionLocalServiceUtil.
2296 getAvailableResourcePermissionActionIds(
2297 companyId, className, ResourceConstants.SCOPE_INDIVIDUAL,
2298 String.valueOf(primKey), roleIds, actionIds);
2299 }
2300 }
2301
2302 protected long getClassPK(ClassedModel classedModel) {
2303 if (classedModel instanceof ResourcedModel) {
2304 ResourcedModel resourcedModel = (ResourcedModel)classedModel;
2305
2306 return resourcedModel.getResourcePrimKey();
2307 }
2308 else {
2309 return (Long)classedModel.getPrimaryKeyObj();
2310 }
2311 }
2312
2313 protected Element getDataElement(
2314 Element parentElement, String attribute, String value) {
2315
2316 if (parentElement == null) {
2317 return null;
2318 }
2319
2320 StringBundler sb = new StringBundler(6);
2321
2322 sb.append("staged-model");
2323 sb.append("[@");
2324 sb.append(attribute);
2325 sb.append(StringPool.EQUAL);
2326 sb.append(HtmlUtil.escapeXPathAttribute(value));
2327 sb.append(StringPool.CLOSE_BRACKET);
2328
2329 XPath xPath = SAXReaderUtil.createXPath(sb.toString());
2330
2331 return (Element)xPath.selectSingleNode(parentElement);
2332 }
2333
2334 protected String getExpandoPath(String path) {
2335 return ExportImportPathUtil.getExpandoPath(path);
2336 }
2337
2338 protected Element getExportDataGroupElement(String name) {
2339 if (_exportDataRootElement == null) {
2340 throw new IllegalStateException(
2341 "Root data element not initialized");
2342 }
2343
2344 Element groupElement = _exportDataRootElement.element(name);
2345
2346 if (groupElement == null) {
2347 groupElement = _exportDataRootElement.addElement(name);
2348 }
2349
2350 return groupElement;
2351 }
2352
2353 protected Element getImportDataGroupElement(String name) {
2354 if (_importDataRootElement == null) {
2355 throw new IllegalStateException(
2356 "Root data element not initialized");
2357 }
2358
2359 if (Validator.isNull(name)) {
2360 return SAXReaderUtil.createElement("EMPTY-ELEMENT");
2361 }
2362
2363 Element groupElement = _importDataRootElement.element(name);
2364
2365 if (groupElement == null) {
2366 return SAXReaderUtil.createElement("EMPTY-ELEMENT");
2367 }
2368
2369 return groupElement;
2370 }
2371
2372 protected Element getMissingReferenceElement(ClassedModel classedModel) {
2373 StringBundler sb = new StringBundler(5);
2374
2375 sb.append("missing-reference[@class-name='");
2376 sb.append(ExportImportClassedModelUtil.getClassName(classedModel));
2377 sb.append("' and @class-pk='");
2378 sb.append(String.valueOf(classedModel.getPrimaryKeyObj()));
2379 sb.append("']");
2380
2381 XPath xPath = SAXReaderUtil.createXPath(sb.toString());
2382
2383 Node node = xPath.selectSingleNode(_missingReferencesElement);
2384
2385 return (Element)node;
2386 }
2387
2388 protected String getPrimaryKeyString(Class<?> clazz, long classPK) {
2389 return getPrimaryKeyString(clazz.getName(), String.valueOf(classPK));
2390 }
2391
2392 protected String getPrimaryKeyString(Class<?> clazz, String primaryKey) {
2393 return getPrimaryKeyString(clazz.getName(), primaryKey);
2394 }
2395
2396 protected String getPrimaryKeyString(String className, long classPK) {
2397 return getPrimaryKeyString(className, String.valueOf(classPK));
2398 }
2399
2400 protected String getPrimaryKeyString(String className, String primaryKey) {
2401 return className.concat(StringPool.POUND).concat(primaryKey);
2402 }
2403
2404 protected List<Element> getReferenceDataElements(
2405 List<Element> referenceElements, Class<?> clazz) {
2406
2407 List<Element> referenceDataElements = new ArrayList<Element>();
2408
2409 for (Element referenceElement : referenceElements) {
2410 Element referenceDataElement = null;
2411
2412 String path = referenceElement.attributeValue("path");
2413
2414 if (Validator.isNotNull(path)) {
2415 referenceDataElement = getImportDataElement(
2416 clazz.getSimpleName(), "path", path);
2417 }
2418 else {
2419 String groupId = referenceElement.attributeValue("group-id");
2420 String uuid = referenceElement.attributeValue("uuid");
2421
2422 StringBuilder sb = new StringBuilder(5);
2423
2424 sb.append("staged-model[@uuid=");
2425 sb.append(HtmlUtil.escapeXPathAttribute(uuid));
2426
2427 if (groupId != null) {
2428 sb.append(" and @group-id=");
2429 sb.append(HtmlUtil.escapeXPathAttribute(groupId));
2430 }
2431
2432 sb.append(StringPool.CLOSE_BRACKET);
2433
2434 XPath xPath = SAXReaderUtil.createXPath(sb.toString());
2435
2436 Element groupElement = getImportDataGroupElement(
2437 clazz.getSimpleName());
2438
2439 referenceDataElement = (Element)xPath.selectSingleNode(
2440 groupElement);
2441 }
2442
2443 if (referenceDataElement == null) {
2444 continue;
2445 }
2446
2447 referenceDataElements.add(referenceDataElement);
2448 }
2449
2450 return referenceDataElements;
2451 }
2452
2453 protected List<Element> getReferenceElements(
2454 Element parentElement, Class<?> clazz, long groupId, String uuid,
2455 long classPK, String referenceType) {
2456
2457 if (parentElement == null) {
2458 return Collections.emptyList();
2459 }
2460
2461 Element referencesElement = parentElement.element("references");
2462
2463 if (referencesElement == null) {
2464 return Collections.emptyList();
2465 }
2466
2467 StringBundler sb = new StringBundler(13);
2468
2469 sb.append("reference[@class-name=");
2470 sb.append(HtmlUtil.escapeXPathAttribute(clazz.getName()));
2471
2472 if (groupId > 0) {
2473 sb.append(" and @group-id='");
2474 sb.append(groupId);
2475 sb.append(StringPool.APOSTROPHE);
2476 }
2477
2478 if (Validator.isNotNull(uuid)) {
2479 sb.append(" and @uuid=");
2480 sb.append(HtmlUtil.escapeXPathAttribute(uuid));
2481 }
2482
2483 if (classPK > 0) {
2484 sb.append(" and @class-pk='");
2485 sb.append(classPK);
2486 sb.append(StringPool.APOSTROPHE);
2487 }
2488
2489 if (referenceType != null) {
2490 sb.append(" and @type=");
2491 sb.append(HtmlUtil.escapeXPathAttribute(referenceType));
2492 }
2493
2494 sb.append(StringPool.CLOSE_BRACKET);
2495
2496 XPath xPath = SAXReaderUtil.createXPath(sb.toString());
2497
2498 List<Node> nodes = xPath.selectNodes(referencesElement);
2499
2500 return ListUtil.fromArray(nodes.toArray(new Element[nodes.size()]));
2501 }
2502
2503 protected List<Element> getReferenceElements(
2504 StagedModel parentStagedModel, Class<?> clazz, long classPK,
2505 String referenceType) {
2506
2507 Element stagedModelElement = getImportDataStagedModelElement(
2508 parentStagedModel);
2509
2510 return getReferenceElements(
2511 stagedModelElement, clazz, 0, null, classPK, referenceType);
2512 }
2513
2514 protected String getReferenceKey(ClassedModel classedModel) {
2515 return getReferenceKey(
2516 ExportImportClassedModelUtil.getClassName(classedModel),
2517 String.valueOf(classedModel.getPrimaryKeyObj()));
2518 }
2519
2520 protected String getReferenceKey(String className, String classPK) {
2521 return className.concat(StringPool.POUND).concat(classPK);
2522 }
2523
2524 protected long getUserId(AuditedModel auditedModel) {
2525 try {
2526 String userUuid = auditedModel.getUserUuid();
2527
2528 return getUserId(userUuid);
2529 }
2530 catch (SystemException se) {
2531 if (_log.isErrorEnabled()) {
2532 _log.error(se, se);
2533 }
2534 }
2535
2536 return 0;
2537 }
2538
2539 protected void initXStream() {
2540 _xStream = new XStream();
2541
2542 _xStream.alias("BlogsEntry", BlogsEntryImpl.class);
2543 _xStream.alias("BookmarksFolder", BookmarksFolderImpl.class);
2544 _xStream.alias("BookmarksEntry", BookmarksEntryImpl.class);
2545 _xStream.alias("DLFolder", DLFolderImpl.class);
2546 _xStream.alias("DLFileEntry", DLFileEntryImpl.class);
2547 _xStream.alias("DLFileShortcut", DLFileShortcutImpl.class);
2548 _xStream.alias("JournalArticle", JournalArticleImpl.class);
2549 _xStream.alias("JournalFeed", JournalFeedImpl.class);
2550 _xStream.alias("Lock", LockImpl.class);
2551 _xStream.alias("MBBan", MBBanImpl.class);
2552 _xStream.alias("MBCategory", MBCategoryImpl.class);
2553 _xStream.alias("MBMessage", MBMessageImpl.class);
2554 _xStream.alias("MBThreadFlag", MBThreadFlagImpl.class);
2555 _xStream.alias("PollsQuestion", PollsQuestionImpl.class);
2556 _xStream.alias("PollsChoice", PollsChoiceImpl.class);
2557 _xStream.alias("PollsVote", PollsVoteImpl.class);
2558 _xStream.alias("RatingsEntry", RatingsEntryImpl.class);
2559 _xStream.alias("WikiNode", WikiNodeImpl.class);
2560 _xStream.alias("WikiPage", WikiPageImpl.class);
2561
2562 _xStream.omitField(HashMap.class, "cache_bitmask");
2563 }
2564
2565 protected boolean isResourceMain(ClassedModel classedModel) {
2566 if (classedModel instanceof ResourcedModel) {
2567 ResourcedModel resourcedModel = (ResourcedModel)classedModel;
2568
2569 return resourcedModel.isResourceMain();
2570 }
2571
2572 return true;
2573 }
2574
2575 private static Log _log = LogFactoryUtil.getLog(
2576 PortletDataContextImpl.class);
2577
2578 private Map<String, long[]> _assetCategoryIdsMap =
2579 new HashMap<String, long[]>();
2580 private Map<String, String[]> _assetCategoryUuidsMap =
2581 new HashMap<String, String[]>();
2582 private Map<String, List<AssetLink>> _assetLinksMap =
2583 new HashMap<String, List<AssetLink>>();
2584 private Map<String, String[]> _assetTagNamesMap =
2585 new HashMap<String, String[]>();
2586 private Map<String, List<MBMessage>> _commentsMap =
2587 new HashMap<String, List<MBMessage>>();
2588 private long _companyGroupId;
2589 private long _companyId;
2590 private String _dataStrategy;
2591 private Set<StagedModelType> _deletionSystemEventModelTypes =
2592 new HashSet<StagedModelType>();
2593 private Date _endDate;
2594 private Map<String, List<ExpandoColumn>> _expandoColumnsMap =
2595 new HashMap<String, List<ExpandoColumn>>();
2596 private Element _exportDataRootElement;
2597 private long _groupId;
2598 private Element _importDataRootElement;
2599 private Map<String, Lock> _locksMap = new HashMap<String, Lock>();
2600 private ManifestSummary _manifestSummary = new ManifestSummary();
2601 private Set<String> _missingReferences = new HashSet<String>();
2602 private Element _missingReferencesElement;
2603 private List<Layout> _newLayouts;
2604 private Map<String, Map<?, ?>> _newPrimaryKeysMaps =
2605 new HashMap<String, Map<?, ?>>();
2606 private Set<String> _notUniquePerLayout = new HashSet<String>();
2607 private long _oldPlid;
2608 private Map<String, String[]> _parameterMap;
2609 private Map<String, List<KeyValuePair>> _permissionsMap =
2610 new HashMap<String, List<KeyValuePair>>();
2611 private long _plid;
2612 private PortletDataContextListener _portletDataContextListener;
2613 private Set<String> _primaryKeys = new HashSet<String>();
2614 private boolean _privateLayout;
2615 private Map<String, List<RatingsEntry>> _ratingsEntriesMap =
2616 new HashMap<String, List<RatingsEntry>>();
2617 private Set<String> _references = new HashSet<String>();
2618 private Set<String> _scopedPrimaryKeys = new HashSet<String>();
2619 private long _scopeGroupId;
2620 private String _scopeLayoutUuid;
2621 private String _scopeType;
2622 private long _sourceCompanyGroupId;
2623 private long _sourceCompanyId;
2624 private long _sourceGroupId;
2625 private long _sourceUserPersonalSiteGroupId;
2626 private Date _startDate;
2627 private UserIdStrategy _userIdStrategy;
2628 private long _userPersonalSiteGroupId;
2629 private XStream _xStream;
2630 private ZipReader _zipReader;
2631 private ZipWriter _zipWriter;
2632
2633 }