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