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