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