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