001
014
015 package com.liferay.portal.service.impl;
016
017 import com.liferay.portal.exception.NoSuchLayoutException;
018 import com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable;
019 import com.liferay.portal.kernel.exception.PortalException;
020 import com.liferay.portal.kernel.messaging.DestinationNames;
021 import com.liferay.portal.kernel.repository.model.FileEntry;
022 import com.liferay.portal.kernel.scheduler.SchedulerEngineHelperUtil;
023 import com.liferay.portal.kernel.scheduler.StorageType;
024 import com.liferay.portal.kernel.scheduler.Trigger;
025 import com.liferay.portal.kernel.scheduler.TriggerFactoryUtil;
026 import com.liferay.portal.kernel.security.permission.ActionKeys;
027 import com.liferay.portal.kernel.security.permission.PermissionChecker;
028 import com.liferay.portal.kernel.util.Digester;
029 import com.liferay.portal.kernel.util.DigesterUtil;
030 import com.liferay.portal.kernel.util.GetterUtil;
031 import com.liferay.portal.kernel.util.MapUtil;
032 import com.liferay.portal.kernel.util.TempFileEntryUtil;
033 import com.liferay.portal.kernel.util.Validator;
034 import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
035 import com.liferay.portal.model.Group;
036 import com.liferay.portal.model.Layout;
037 import com.liferay.portal.model.LayoutConstants;
038 import com.liferay.portal.model.LayoutReference;
039 import com.liferay.portal.model.LayoutTypePortlet;
040 import com.liferay.portal.model.Plugin;
041 import com.liferay.portal.model.User;
042 import com.liferay.portal.service.ServiceContext;
043 import com.liferay.portal.service.base.LayoutServiceBaseImpl;
044 import com.liferay.portal.service.permission.GroupPermissionUtil;
045 import com.liferay.portal.service.permission.LayoutPermissionUtil;
046 import com.liferay.portal.service.permission.PortletPermissionUtil;
047 import com.liferay.portal.util.PortletKeys;
048 import com.liferay.portlet.PortletPreferencesFactoryUtil;
049 import com.liferay.portlet.exportimport.configuration.ExportImportConfigurationConstants;
050 import com.liferay.portlet.exportimport.configuration.ExportImportConfigurationSettingsMapFactory;
051 import com.liferay.portlet.exportimport.lar.ExportImportHelperUtil;
052 import com.liferay.portlet.exportimport.lar.MissingReferences;
053 import com.liferay.portlet.exportimport.model.ExportImportConfiguration;
054
055 import java.io.File;
056 import java.io.InputStream;
057 import java.io.Serializable;
058
059 import java.util.ArrayList;
060 import java.util.Date;
061 import java.util.List;
062 import java.util.Locale;
063 import java.util.Map;
064
065
074 public class LayoutServiceImpl extends LayoutServiceBaseImpl {
075
076
114 @Override
115 public Layout addLayout(
116 long groupId, boolean privateLayout, long parentLayoutId,
117 Map<Locale, String> localeNamesMap,
118 Map<Locale, String> localeTitlesMap,
119 Map<Locale, String> descriptionMap, Map<Locale, String> keywordsMap,
120 Map<Locale, String> robotsMap, String type, String typeSettings,
121 boolean hidden, Map<Locale, String> friendlyURLMap,
122 ServiceContext serviceContext)
123 throws PortalException {
124
125 PermissionChecker permissionChecker = getPermissionChecker();
126
127 if (parentLayoutId == LayoutConstants.DEFAULT_PARENT_LAYOUT_ID) {
128 GroupPermissionUtil.check(
129 permissionChecker, groupId, ActionKeys.ADD_LAYOUT);
130 }
131 else {
132 LayoutPermissionUtil.check(
133 permissionChecker, groupId, privateLayout, parentLayoutId,
134 ActionKeys.ADD_LAYOUT);
135 }
136
137 return layoutLocalService.addLayout(
138 getUserId(), groupId, privateLayout, parentLayoutId, localeNamesMap,
139 localeTitlesMap, descriptionMap, keywordsMap, robotsMap, type,
140 typeSettings, hidden, friendlyURLMap, serviceContext);
141 }
142
143
177 @Override
178 public Layout addLayout(
179 long groupId, boolean privateLayout, long parentLayoutId,
180 String name, String title, String description, String type,
181 boolean hidden, String friendlyURL, ServiceContext serviceContext)
182 throws PortalException {
183
184 PermissionChecker permissionChecker = getPermissionChecker();
185
186 if (parentLayoutId == LayoutConstants.DEFAULT_PARENT_LAYOUT_ID) {
187 GroupPermissionUtil.check(
188 permissionChecker, groupId, ActionKeys.ADD_LAYOUT);
189 }
190 else {
191 LayoutPermissionUtil.check(
192 permissionChecker, groupId, privateLayout, parentLayoutId,
193 ActionKeys.ADD_LAYOUT);
194 }
195
196 return layoutLocalService.addLayout(
197 getUserId(), groupId, privateLayout, parentLayoutId, name, title,
198 description, type, hidden, friendlyURL, serviceContext);
199 }
200
201 @Override
202 public FileEntry addTempFileEntry(
203 long groupId, String folderName, String fileName,
204 InputStream inputStream, String mimeType)
205 throws PortalException {
206
207 GroupPermissionUtil.check(
208 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
209
210 return TempFileEntryUtil.addTempFileEntry(
211 groupId, getUserId(),
212 DigesterUtil.digestHex(Digester.SHA_256, folderName), fileName,
213 inputStream, mimeType);
214 }
215
216
225 @Override
226 public void deleteLayout(
227 long groupId, boolean privateLayout, long layoutId,
228 ServiceContext serviceContext)
229 throws PortalException {
230
231 LayoutPermissionUtil.check(
232 getPermissionChecker(), groupId, privateLayout, layoutId,
233 ActionKeys.DELETE);
234
235 layoutLocalService.deleteLayout(
236 groupId, privateLayout, layoutId, serviceContext);
237 }
238
239
246 @Override
247 public void deleteLayout(long plid, ServiceContext serviceContext)
248 throws PortalException {
249
250 LayoutPermissionUtil.check(
251 getPermissionChecker(), plid, ActionKeys.DELETE);
252
253 layoutLocalService.deleteLayout(plid, serviceContext);
254 }
255
256 @Override
257 public void deleteTempFileEntry(
258 long groupId, String folderName, String fileName)
259 throws PortalException {
260
261 GroupPermissionUtil.check(
262 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
263
264 TempFileEntryUtil.deleteTempFileEntry(
265 groupId, getUserId(),
266 DigesterUtil.digestHex(Digester.SHA_256, folderName), fileName);
267 }
268
269
285 @Deprecated
286 @Override
287 public byte[] exportLayouts(
288 long groupId, boolean privateLayout, long[] layoutIds,
289 Map<String, String[]> parameterMap, Date startDate, Date endDate)
290 throws PortalException {
291
292 GroupPermissionUtil.check(
293 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
294
295 return layoutLocalService.exportLayouts(
296 groupId, privateLayout, layoutIds, parameterMap, startDate,
297 endDate);
298 }
299
300
314 @Deprecated
315 @Override
316 public byte[] exportLayouts(
317 long groupId, boolean privateLayout,
318 Map<String, String[]> parameterMap, Date startDate, Date endDate)
319 throws PortalException {
320
321 GroupPermissionUtil.check(
322 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
323
324 return layoutLocalService.exportLayouts(
325 groupId, privateLayout, parameterMap, startDate, endDate);
326 }
327
328
333 @Deprecated
334 @Override
335 public File exportLayoutsAsFile(
336 ExportImportConfiguration exportImportConfiguration)
337 throws PortalException {
338
339 Map<String, Serializable> settingsMap =
340 exportImportConfiguration.getSettingsMap();
341
342 long sourceGroupId = MapUtil.getLong(settingsMap, "sourceGroupId");
343
344 GroupPermissionUtil.check(
345 getPermissionChecker(), sourceGroupId,
346 ActionKeys.EXPORT_IMPORT_LAYOUTS);
347
348 return layoutLocalService.exportLayoutsAsFile(
349 exportImportConfiguration);
350 }
351
352
368 @Deprecated
369 @Override
370 public File exportLayoutsAsFile(
371 long groupId, boolean privateLayout, long[] layoutIds,
372 Map<String, String[]> parameterMap, Date startDate, Date endDate)
373 throws PortalException {
374
375 GroupPermissionUtil.check(
376 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
377
378 return layoutLocalService.exportLayoutsAsFile(
379 groupId, privateLayout, layoutIds, parameterMap, startDate,
380 endDate);
381 }
382
383
388 @Deprecated
389 @Override
390 public long exportLayoutsAsFileInBackground(
391 ExportImportConfiguration exportImportConfiguration)
392 throws PortalException {
393
394 GroupPermissionUtil.check(
395 getPermissionChecker(), exportImportConfiguration.getGroupId(),
396 ActionKeys.EXPORT_IMPORT_LAYOUTS);
397
398 return layoutLocalService.exportLayoutsAsFileInBackground(
399 getUserId(), exportImportConfiguration);
400 }
401
402
407 @Deprecated
408 @Override
409 public long exportLayoutsAsFileInBackground(
410 long exportImportConfigurationId)
411 throws PortalException {
412
413 ExportImportConfiguration exportImportConfiguration =
414 exportImportConfigurationLocalService.getExportImportConfiguration(
415 exportImportConfigurationId);
416
417 GroupPermissionUtil.check(
418 getPermissionChecker(), exportImportConfiguration.getGroupId(),
419 ActionKeys.EXPORT_IMPORT_LAYOUTS);
420
421 return layoutLocalService.exportLayoutsAsFileInBackground(
422 getUserId(), exportImportConfigurationId);
423 }
424
425
428 @Deprecated
429 @Override
430 public long exportLayoutsAsFileInBackground(
431 String taskName, long groupId, boolean privateLayout,
432 long[] layoutIds, Map<String, String[]> parameterMap,
433 Date startDate, Date endDate)
434 throws PortalException {
435
436 GroupPermissionUtil.check(
437 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
438
439 return layoutLocalService.exportLayoutsAsFileInBackground(
440 getUserId(), taskName, groupId, privateLayout, layoutIds,
441 parameterMap, startDate, endDate);
442 }
443
444
447 @Deprecated
448 @Override
449 public long exportLayoutsAsFileInBackground(
450 String taskName, long groupId, boolean privateLayout,
451 long[] layoutIds, Map<String, String[]> parameterMap,
452 Date startDate, Date endDate, String fileName)
453 throws PortalException {
454
455 GroupPermissionUtil.check(
456 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
457
458 return layoutLocalService.exportLayoutsAsFileInBackground(
459 getUserId(), taskName, groupId, privateLayout, layoutIds,
460 parameterMap, startDate, endDate, fileName);
461 }
462
463
479 @Deprecated
480 @Override
481 public byte[] exportPortletInfo(
482 long plid, long groupId, String portletId,
483 Map<String, String[]> parameterMap, Date startDate, Date endDate)
484 throws PortalException {
485
486 Layout layout = layoutLocalService.getLayout(plid);
487
488 GroupPermissionUtil.check(
489 getPermissionChecker(), layout.getGroupId(),
490 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
491
492 return layoutLocalService.exportPortletInfo(
493 plid, groupId, portletId, parameterMap, startDate, endDate);
494 }
495
496
499 @Deprecated
500 @Override
501 public byte[] exportPortletInfo(
502 long companyId, String portletId,
503 Map<String, String[]> parameterMap, Date startDate, Date endDate)
504 throws PortalException {
505
506 Group companyGroup = groupLocalService.getCompanyGroup(companyId);
507
508 GroupPermissionUtil.check(
509 getPermissionChecker(), companyGroup,
510 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
511
512 return layoutLocalService.exportPortletInfo(
513 companyId, portletId, parameterMap, startDate, endDate);
514 }
515
516
521 @Deprecated
522 @Override
523 public File exportPortletInfoAsFile(
524 ExportImportConfiguration exportImportConfiguration)
525 throws PortalException {
526
527 Map<String, Serializable> settingsMap =
528 exportImportConfiguration.getSettingsMap();
529
530 long sourcePlid = MapUtil.getLong(settingsMap, "sourcePlid");
531
532 Layout layout = layoutLocalService.getLayout(sourcePlid);
533
534 GroupPermissionUtil.check(
535 getPermissionChecker(), layout.getGroupId(),
536 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
537
538 return layoutLocalService.exportPortletInfoAsFile(
539 exportImportConfiguration);
540 }
541
542
558 @Deprecated
559 @Override
560 public File exportPortletInfoAsFile(
561 long plid, long groupId, String portletId,
562 Map<String, String[]> parameterMap, Date startDate, Date endDate)
563 throws PortalException {
564
565 Layout layout = layoutLocalService.getLayout(plid);
566
567 GroupPermissionUtil.check(
568 getPermissionChecker(), layout.getGroupId(),
569 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
570
571 return layoutLocalService.exportPortletInfoAsFile(
572 plid, groupId, portletId, parameterMap, startDate, endDate);
573 }
574
575
578 @Deprecated
579 @Override
580 public File exportPortletInfoAsFile(
581 String portletId, Map<String, String[]> parameterMap,
582 Date startDate, Date endDate)
583 throws PortalException {
584
585 User user = userPersistence.findByPrimaryKey(getUserId());
586
587 Group companyGroup = groupLocalService.getCompanyGroup(
588 user.getCompanyId());
589
590 GroupPermissionUtil.check(
591 getPermissionChecker(), companyGroup,
592 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
593
594 return layoutLocalService.exportPortletInfoAsFile(
595 user.getCompanyId(), portletId, parameterMap, startDate, endDate);
596 }
597
598
601 @Deprecated
602 @Override
603 public long exportPortletInfoAsFileInBackground(
604 String taskName, long plid, long groupId, String portletId,
605 Map<String, String[]> parameterMap, Date startDate, Date endDate,
606 String fileName)
607 throws PortalException {
608
609 Layout layout = layoutLocalService.getLayout(plid);
610
611 GroupPermissionUtil.check(
612 getPermissionChecker(), layout.getGroupId(),
613 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
614
615 return layoutLocalService.exportPortletInfoAsFileInBackground(
616 getUserId(), taskName, plid, groupId, portletId, parameterMap,
617 startDate, endDate, fileName);
618 }
619
620
623 @Deprecated
624 @Override
625 public long exportPortletInfoAsFileInBackground(
626 String taskName, String portletId,
627 Map<String, String[]> parameterMap, Date startDate, Date endDate,
628 String fileName)
629 throws PortalException {
630
631 User user = userPersistence.findByPrimaryKey(getUserId());
632
633 Group companyGroup = groupLocalService.getCompanyGroup(
634 user.getCompanyId());
635
636 GroupPermissionUtil.check(
637 getPermissionChecker(), companyGroup,
638 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
639
640 return layoutLocalService.exportPortletInfoAsFileInBackground(
641 getUserId(), taskName, portletId, parameterMap, startDate, endDate,
642 fileName);
643 }
644
645
651 @Override
652 public List<Layout> getAncestorLayouts(long plid) throws PortalException {
653 Layout layout = layoutLocalService.getLayout(plid);
654
655 List<Layout> ancestors = layout.getAncestors();
656
657 return filterLayouts(ancestors);
658 }
659
660
671 @Override
672 public long getDefaultPlid(
673 long groupId, long scopeGroupId, boolean privateLayout,
674 String portletId)
675 throws PortalException {
676
677 if (groupId <= 0) {
678 return LayoutConstants.DEFAULT_PLID;
679 }
680
681 PermissionChecker permissionChecker = getPermissionChecker();
682
683 String scopeGroupLayoutUuid = null;
684
685 Group scopeGroup = groupLocalService.getGroup(scopeGroupId);
686
687 if (scopeGroup.isLayout()) {
688 Layout scopeGroupLayout = layoutLocalService.getLayout(
689 scopeGroup.getClassPK());
690
691 scopeGroupLayoutUuid = scopeGroupLayout.getUuid();
692 }
693
694 Map<Long, javax.portlet.PortletPreferences> jxPortletPreferencesMap =
695 PortletPreferencesFactoryUtil.getPortletSetupMap(
696 scopeGroup.getCompanyId(), groupId,
697 PortletKeys.PREFS_OWNER_ID_DEFAULT,
698 PortletKeys.PREFS_OWNER_TYPE_LAYOUT, portletId, privateLayout);
699
700 for (Map.Entry<Long, javax.portlet.PortletPreferences> entry :
701 jxPortletPreferencesMap.entrySet()) {
702
703 long plid = entry.getKey();
704
705 Layout layout = null;
706
707 try {
708 layout = layoutLocalService.getLayout(plid);
709 }
710 catch (NoSuchLayoutException nsle) {
711 continue;
712 }
713
714 if (!LayoutPermissionUtil.contains(
715 permissionChecker, layout, ActionKeys.VIEW)) {
716
717 continue;
718 }
719
720 if (!layout.isTypePortlet()) {
721 continue;
722 }
723
724 LayoutTypePortlet layoutTypePortlet =
725 (LayoutTypePortlet)layout.getLayoutType();
726
727 if (!layoutTypePortlet.hasPortletId(portletId)) {
728 continue;
729 }
730
731 javax.portlet.PortletPreferences jxPortletPreferences =
732 entry.getValue();
733
734 String scopeType = GetterUtil.getString(
735 jxPortletPreferences.getValue("lfrScopeType", null));
736
737 if (scopeGroup.isLayout()) {
738 String scopeLayoutUuid = GetterUtil.getString(
739 jxPortletPreferences.getValue("lfrScopeLayoutUuid", null));
740
741 if (Validator.isNotNull(scopeType) &&
742 Validator.isNotNull(scopeLayoutUuid) &&
743 scopeLayoutUuid.equals(scopeGroupLayoutUuid)) {
744
745 return layout.getPlid();
746 }
747 }
748 else if (scopeGroup.isCompany()) {
749 if (Validator.isNotNull(scopeType) &&
750 scopeType.equals("company")) {
751
752 return layout.getPlid();
753 }
754 }
755 else {
756 if (Validator.isNull(scopeType)) {
757 return layout.getPlid();
758 }
759 }
760 }
761
762 return LayoutConstants.DEFAULT_PLID;
763 }
764
765 @Override
766 @ThreadLocalCachable
767 public long getDefaultPlid(
768 long groupId, long scopeGroupId, String portletId)
769 throws PortalException {
770
771 long plid = getDefaultPlid(groupId, scopeGroupId, false, portletId);
772
773 if (plid == 0) {
774 plid = getDefaultPlid(groupId, scopeGroupId, true, portletId);
775 }
776
777 return plid;
778 }
779
780
788 @Override
789 public Layout getLayoutByUuidAndGroupId(
790 String uuid, long groupId, boolean privateLayout)
791 throws PortalException {
792
793 Layout layout = layoutLocalService.getLayoutByUuidAndGroupId(
794 uuid, groupId, privateLayout);
795
796 LayoutPermissionUtil.check(
797 getPermissionChecker(), layout, ActionKeys.VIEW);
798
799 return layout;
800 }
801
802
812 @Override
813 public String getLayoutName(
814 long groupId, boolean privateLayout, long layoutId,
815 String languageId)
816 throws PortalException {
817
818 Layout layout = layoutLocalService.getLayout(
819 groupId, privateLayout, layoutId);
820
821 return layout.getName(languageId);
822 }
823
824
834 @Override
835 public LayoutReference[] getLayoutReferences(
836 long companyId, String portletId, String preferencesKey,
837 String preferencesValue) {
838
839 return layoutLocalService.getLayouts(
840 companyId, portletId, preferencesKey, preferencesValue);
841 }
842
843 @Override
844 public List<Layout> getLayouts(long groupId, boolean privateLayout) {
845 return layoutPersistence.filterFindByG_P(groupId, privateLayout);
846 }
847
848 @Override
849 public List<Layout> getLayouts(
850 long groupId, boolean privateLayout, long parentLayoutId)
851 throws PortalException {
852
853 List<Layout> layouts = layoutLocalService.getLayouts(
854 groupId, privateLayout, parentLayoutId);
855
856 return filterLayouts(layouts);
857 }
858
859 @Override
860 public List<Layout> getLayouts(
861 long groupId, boolean privateLayout, long parentLayoutId,
862 boolean incomplete, int start, int end)
863 throws PortalException {
864
865 List<Layout> layouts = layoutLocalService.getLayouts(
866 groupId, privateLayout, parentLayoutId, incomplete, start, end);
867
868 return filterLayouts(layouts);
869 }
870
871 @Override
872 public int getLayoutsCount(
873 long groupId, boolean privateLayout, long parentLayoutId) {
874
875 return layoutPersistence.filterCountByG_P_P(
876 groupId, privateLayout, parentLayoutId);
877 }
878
879 @Override
880 public String[] getTempFileNames(long groupId, String folderName)
881 throws PortalException {
882
883 GroupPermissionUtil.check(
884 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
885
886 return TempFileEntryUtil.getTempFileNames(
887 groupId, getUserId(),
888 DigesterUtil.digestHex(Digester.SHA_256, folderName));
889 }
890
891
896 @Deprecated
897 @Override
898 public void importLayouts(
899 ExportImportConfiguration exportImportConfiguration, File file)
900 throws PortalException {
901
902 Map<String, Serializable> settingsMap =
903 exportImportConfiguration.getSettingsMap();
904
905 long targetGroupId = MapUtil.getLong(settingsMap, "targetGroupId");
906
907 GroupPermissionUtil.check(
908 getPermissionChecker(), targetGroupId,
909 ActionKeys.EXPORT_IMPORT_LAYOUTS);
910
911 layoutLocalService.importLayouts(exportImportConfiguration, file);
912 }
913
914
919 @Deprecated
920 @Override
921 public void importLayouts(
922 ExportImportConfiguration exportImportConfiguration, InputStream is)
923 throws PortalException {
924
925 Map<String, Serializable> settingsMap =
926 exportImportConfiguration.getSettingsMap();
927
928 long targetGroupId = MapUtil.getLong(settingsMap, "targetGroupId");
929
930 GroupPermissionUtil.check(
931 getPermissionChecker(), targetGroupId,
932 ActionKeys.EXPORT_IMPORT_LAYOUTS);
933
934 layoutLocalService.importLayouts(exportImportConfiguration, is);
935 }
936
937
950 @Deprecated
951 @Override
952 public void importLayouts(
953 long groupId, boolean privateLayout,
954 Map<String, String[]> parameterMap, byte[] bytes)
955 throws PortalException {
956
957 GroupPermissionUtil.check(
958 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
959
960 layoutLocalService.importLayouts(
961 getUserId(), groupId, privateLayout, parameterMap, bytes);
962 }
963
964
977 @Deprecated
978 @Override
979 public void importLayouts(
980 long groupId, boolean privateLayout,
981 Map<String, String[]> parameterMap, File file)
982 throws PortalException {
983
984 GroupPermissionUtil.check(
985 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
986
987 layoutLocalService.importLayouts(
988 getUserId(), groupId, privateLayout, parameterMap, file);
989 }
990
991
1004 @Deprecated
1005 @Override
1006 public void importLayouts(
1007 long groupId, boolean privateLayout,
1008 Map<String, String[]> parameterMap, InputStream is)
1009 throws PortalException {
1010
1011 GroupPermissionUtil.check(
1012 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
1013
1014 layoutLocalService.importLayouts(
1015 getUserId(), groupId, privateLayout, parameterMap, is);
1016 }
1017
1018
1021 @Deprecated
1022 @Override
1023 public long importLayoutsInBackground(
1024 String taskName, long groupId, boolean privateLayout,
1025 Map<String, String[]> parameterMap, File file)
1026 throws PortalException {
1027
1028 GroupPermissionUtil.check(
1029 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
1030
1031 return layoutLocalService.importLayoutsInBackground(
1032 getUserId(), taskName, groupId, privateLayout, parameterMap, file);
1033 }
1034
1035
1038 @Deprecated
1039 @Override
1040 public long importLayoutsInBackground(
1041 String taskName, long groupId, boolean privateLayout,
1042 Map<String, String[]> parameterMap, InputStream inputStream)
1043 throws PortalException {
1044
1045 GroupPermissionUtil.check(
1046 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
1047
1048 return layoutLocalService.importLayoutsInBackground(
1049 getUserId(), taskName, groupId, privateLayout, parameterMap,
1050 inputStream);
1051 }
1052
1053
1058 @Deprecated
1059 @Override
1060 public void importPortletInfo(
1061 ExportImportConfiguration exportImportConfiguration, File file)
1062 throws PortalException {
1063
1064 Map<String, Serializable> settingsMap =
1065 exportImportConfiguration.getSettingsMap();
1066
1067 long targetGroupId = MapUtil.getLong(settingsMap, "targetGroupId");
1068
1069 GroupPermissionUtil.check(
1070 getPermissionChecker(), targetGroupId,
1071 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
1072
1073 layoutLocalService.importPortletInfo(exportImportConfiguration, file);
1074 }
1075
1076
1081 @Deprecated
1082 @Override
1083 public void importPortletInfo(
1084 ExportImportConfiguration exportImportConfiguration, InputStream is)
1085 throws PortalException {
1086
1087 Map<String, Serializable> settingsMap =
1088 exportImportConfiguration.getSettingsMap();
1089
1090 long targetGroupId = MapUtil.getLong(settingsMap, "targetGroupId");
1091
1092 GroupPermissionUtil.check(
1093 getPermissionChecker(), targetGroupId,
1094 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
1095
1096 layoutLocalService.importPortletInfo(exportImportConfiguration, is);
1097 }
1098
1099
1113 @Deprecated
1114 @Override
1115 public void importPortletInfo(
1116 long plid, long groupId, String portletId,
1117 Map<String, String[]> parameterMap, File file)
1118 throws PortalException {
1119
1120 GroupPermissionUtil.check(
1121 getPermissionChecker(), groupId,
1122 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
1123
1124 layoutLocalService.importPortletInfo(
1125 getUserId(), plid, groupId, portletId, parameterMap, file);
1126 }
1127
1128
1142 @Deprecated
1143 @Override
1144 public void importPortletInfo(
1145 long plid, long groupId, String portletId,
1146 Map<String, String[]> parameterMap, InputStream is)
1147 throws PortalException {
1148
1149 GroupPermissionUtil.check(
1150 getPermissionChecker(), groupId,
1151 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
1152
1153 layoutLocalService.importPortletInfo(
1154 getUserId(), plid, groupId, portletId, parameterMap, is);
1155 }
1156
1157
1160 @Deprecated
1161 @Override
1162 public void importPortletInfo(
1163 String portletId, Map<String, String[]> parameterMap, File file)
1164 throws PortalException {
1165
1166 User user = userPersistence.findByPrimaryKey(getUserId());
1167
1168 Group companyGroup = groupLocalService.getCompanyGroup(
1169 user.getCompanyId());
1170
1171 GroupPermissionUtil.check(
1172 getPermissionChecker(), companyGroup,
1173 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
1174
1175 layoutLocalService.importPortletInfo(
1176 getUserId(), portletId, parameterMap, file);
1177 }
1178
1179
1182 @Deprecated
1183 @Override
1184 public void importPortletInfo(
1185 String portletId, Map<String, String[]> parameterMap,
1186 InputStream is)
1187 throws PortalException {
1188
1189 User user = userPersistence.findByPrimaryKey(getUserId());
1190
1191 Group companyGroup = groupLocalService.getCompanyGroup(
1192 user.getCompanyId());
1193
1194 GroupPermissionUtil.check(
1195 getPermissionChecker(), companyGroup,
1196 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
1197
1198 layoutLocalService.importPortletInfo(
1199 getUserId(), portletId, parameterMap, is);
1200 }
1201
1202
1205 @Deprecated
1206 @Override
1207 public long importPortletInfoInBackground(
1208 String taskName, long plid, long groupId, String portletId,
1209 Map<String, String[]> parameterMap, File file)
1210 throws PortalException {
1211
1212 GroupPermissionUtil.check(
1213 getPermissionChecker(), groupId,
1214 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
1215
1216 return layoutLocalService.importPortletInfoInBackground(
1217 getUserId(), taskName, plid, groupId, portletId, parameterMap,
1218 file);
1219 }
1220
1221
1224 @Deprecated
1225 @Override
1226 public long importPortletInfoInBackground(
1227 String taskName, long plid, long groupId, String portletId,
1228 Map<String, String[]> parameterMap, InputStream is)
1229 throws PortalException {
1230
1231 GroupPermissionUtil.check(
1232 getPermissionChecker(), groupId,
1233 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
1234
1235 return layoutLocalService.importPortletInfoInBackground(
1236 getUserId(), taskName, plid, groupId, portletId, parameterMap, is);
1237 }
1238
1239
1242 @Deprecated
1243 @Override
1244 public void importPortletInfoInBackground(
1245 String taskName, String portletId,
1246 Map<String, String[]> parameterMap, File file)
1247 throws PortalException {
1248
1249 User user = userPersistence.findByPrimaryKey(getUserId());
1250
1251 Group companyGroup = groupLocalService.getCompanyGroup(
1252 user.getCompanyId());
1253
1254 GroupPermissionUtil.check(
1255 getPermissionChecker(), companyGroup,
1256 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
1257
1258 layoutLocalService.importPortletInfoInBackground(
1259 getUserId(), taskName, portletId, parameterMap, file);
1260 }
1261
1262
1265 @Deprecated
1266 @Override
1267 public void importPortletInfoInBackground(
1268 String taskName, String portletId,
1269 Map<String, String[]> parameterMap, InputStream is)
1270 throws PortalException {
1271
1272 User user = userPersistence.findByPrimaryKey(getUserId());
1273
1274 Group companyGroup = groupLocalService.getCompanyGroup(
1275 user.getCompanyId());
1276
1277 GroupPermissionUtil.check(
1278 getPermissionChecker(), companyGroup,
1279 ActionKeys.EXPORT_IMPORT_PORTLET_INFO);
1280
1281 layoutLocalService.importPortletInfoInBackground(
1282 getUserId(), taskName, portletId, parameterMap, is);
1283 }
1284
1285
1313 @Deprecated
1314 @Override
1315 public void schedulePublishToLive(
1316 long sourceGroupId, long targetGroupId, boolean privateLayout,
1317 long[] layoutIds, Map<String, String[]> parameterMap, String scope,
1318 Date startDate, Date endDate, String groupName, String cronText,
1319 Date schedulerStartDate, Date schedulerEndDate, String description)
1320 throws PortalException {
1321
1322 schedulePublishToLive(
1323 sourceGroupId, targetGroupId, privateLayout, layoutIds,
1324 parameterMap, groupName, cronText, schedulerStartDate,
1325 schedulerEndDate, description);
1326 }
1327
1328
1348 @Override
1349 public void schedulePublishToLive(
1350 long sourceGroupId, long targetGroupId, boolean privateLayout,
1351 long[] layoutIds, Map<String, String[]> parameterMap,
1352 String groupName, String cronText, Date schedulerStartDate,
1353 Date schedulerEndDate, String description)
1354 throws PortalException {
1355
1356 GroupPermissionUtil.check(
1357 getPermissionChecker(), targetGroupId, ActionKeys.PUBLISH_STAGING);
1358
1359 Trigger trigger = TriggerFactoryUtil.createTrigger(
1360 PortalUUIDUtil.generate(), groupName, schedulerStartDate,
1361 schedulerEndDate, cronText);
1362
1363 User user = userPersistence.findByPrimaryKey(getUserId());
1364
1365 Map<String, Serializable> publishLayoutLocalSettingsMap =
1366 ExportImportConfigurationSettingsMapFactory.
1367 buildPublishLayoutLocalSettingsMap(
1368 user, sourceGroupId, targetGroupId, privateLayout,
1369 layoutIds, parameterMap);
1370
1371 ExportImportConfiguration exportImportConfiguration =
1372 exportImportConfigurationLocalService.
1373 addDraftExportImportConfiguration(
1374 getUserId(), description,
1375 ExportImportConfigurationConstants.
1376 TYPE_SCHEDULED_PUBLISH_LAYOUT_LOCAL,
1377 publishLayoutLocalSettingsMap);
1378
1379 SchedulerEngineHelperUtil.schedule(
1380 trigger, StorageType.PERSISTED, description,
1381 DestinationNames.LAYOUTS_LOCAL_PUBLISHER,
1382 exportImportConfiguration.getExportImportConfigurationId(), 0);
1383 }
1384
1385
1410 @Deprecated
1411 @Override
1412 public void schedulePublishToLive(
1413 long sourceGroupId, long targetGroupId, boolean privateLayout,
1414 Map<Long, Boolean> layoutIdMap, Map<String, String[]> parameterMap,
1415 String scope, Date startDate, Date endDate, String groupName,
1416 String cronText, Date schedulerStartDate, Date schedulerEndDate,
1417 String description)
1418 throws PortalException {
1419
1420 schedulePublishToLive(
1421 sourceGroupId, targetGroupId, privateLayout,
1422 ExportImportHelperUtil.getLayoutIds(layoutIdMap, targetGroupId),
1423 parameterMap, groupName, cronText, schedulerStartDate,
1424 schedulerEndDate, description);
1425 }
1426
1427
1454 @Override
1455 public void schedulePublishToRemote(
1456 long sourceGroupId, boolean privateLayout,
1457 Map<Long, Boolean> layoutIdMap, Map<String, String[]> parameterMap,
1458 String remoteAddress, int remotePort, String remotePathContext,
1459 boolean secureConnection, long remoteGroupId,
1460 boolean remotePrivateLayout, Date startDate, Date endDate,
1461 String groupName, String cronText, Date schedulerStartDate,
1462 Date schedulerEndDate, String description)
1463 throws PortalException {
1464
1465 GroupPermissionUtil.check(
1466 getPermissionChecker(), sourceGroupId, ActionKeys.PUBLISH_STAGING);
1467
1468 Trigger trigger = TriggerFactoryUtil.createTrigger(
1469 PortalUUIDUtil.generate(), groupName, schedulerStartDate,
1470 schedulerEndDate, cronText);
1471
1472 User user = userPersistence.findByPrimaryKey(getUserId());
1473
1474 Map<String, Serializable> publishLayoutRemoteSettingsMap =
1475 ExportImportConfigurationSettingsMapFactory.
1476 buildPublishLayoutRemoteSettingsMap(
1477 getUserId(), sourceGroupId, privateLayout, layoutIdMap,
1478 parameterMap, remoteAddress, remotePort, remotePathContext,
1479 secureConnection, remoteGroupId, remotePrivateLayout,
1480 user.getLocale(), user.getTimeZone());
1481
1482 ExportImportConfiguration exportImportConfiguration =
1483 exportImportConfigurationLocalService.
1484 addDraftExportImportConfiguration(
1485 getUserId(), description,
1486 ExportImportConfigurationConstants.
1487 TYPE_SCHEDULED_PUBLISH_LAYOUT_REMOTE,
1488 publishLayoutRemoteSettingsMap);
1489
1490 SchedulerEngineHelperUtil.schedule(
1491 trigger, StorageType.PERSISTED, description,
1492 DestinationNames.LAYOUTS_REMOTE_PUBLISHER,
1493 exportImportConfiguration.getExportImportConfigurationId(), 0);
1494 }
1495
1496
1506 @Override
1507 public void setLayouts(
1508 long groupId, boolean privateLayout, long parentLayoutId,
1509 long[] layoutIds, ServiceContext serviceContext)
1510 throws PortalException {
1511
1512 GroupPermissionUtil.check(
1513 getPermissionChecker(), groupId, ActionKeys.UPDATE);
1514
1515 layoutLocalService.setLayouts(
1516 groupId, privateLayout, parentLayoutId, layoutIds, serviceContext);
1517 }
1518
1519
1528 @Override
1529 public void unschedulePublishToLive(
1530 long groupId, String jobName, String groupName)
1531 throws PortalException {
1532
1533 GroupPermissionUtil.check(
1534 getPermissionChecker(), groupId, ActionKeys.PUBLISH_STAGING);
1535
1536 SchedulerEngineHelperUtil.delete(
1537 jobName, groupName, StorageType.PERSISTED);
1538 }
1539
1540
1549 @Override
1550 public void unschedulePublishToRemote(
1551 long groupId, String jobName, String groupName)
1552 throws PortalException {
1553
1554 GroupPermissionUtil.check(
1555 getPermissionChecker(), groupId, ActionKeys.PUBLISH_STAGING);
1556
1557 SchedulerEngineHelperUtil.delete(
1558 jobName, groupName, StorageType.PERSISTED);
1559 }
1560
1561 @Override
1562 public Layout updateIconImage(long plid, byte[] bytes)
1563 throws PortalException {
1564
1565 LayoutPermissionUtil.check(
1566 getPermissionChecker(), plid, ActionKeys.UPDATE);
1567
1568 return layoutLocalService.updateIconImage(plid, bytes);
1569 }
1570
1571
1599 @Override
1600 public Layout updateLayout(
1601 long groupId, boolean privateLayout, long layoutId,
1602 long parentLayoutId, Map<Locale, String> localeNamesMap,
1603 Map<Locale, String> localeTitlesMap,
1604 Map<Locale, String> descriptionMap, Map<Locale, String> keywordsMap,
1605 Map<Locale, String> robotsMap, String type, boolean hidden,
1606 Map<Locale, String> friendlyURLMap, boolean iconImage,
1607 byte[] iconBytes, ServiceContext serviceContext)
1608 throws PortalException {
1609
1610 LayoutPermissionUtil.check(
1611 getPermissionChecker(), groupId, privateLayout, layoutId,
1612 ActionKeys.UPDATE);
1613
1614 return layoutLocalService.updateLayout(
1615 groupId, privateLayout, layoutId, parentLayoutId, localeNamesMap,
1616 localeTitlesMap, descriptionMap, keywordsMap, robotsMap, type,
1617 hidden, friendlyURLMap, iconImage, iconBytes, serviceContext);
1618 }
1619
1620
1631 @Override
1632 public Layout updateLayout(
1633 long groupId, boolean privateLayout, long layoutId,
1634 String typeSettings)
1635 throws PortalException {
1636
1637 LayoutPermissionUtil.check(
1638 getPermissionChecker(), groupId, privateLayout, layoutId,
1639 ActionKeys.UPDATE);
1640
1641 return layoutLocalService.updateLayout(
1642 groupId, privateLayout, layoutId, typeSettings);
1643 }
1644
1645
1657 @Override
1658 public Layout updateLookAndFeel(
1659 long groupId, boolean privateLayout, long layoutId, String themeId,
1660 String colorSchemeId, String css, boolean wapTheme)
1661 throws PortalException {
1662
1663 LayoutPermissionUtil.check(
1664 getPermissionChecker(), groupId, privateLayout, layoutId,
1665 ActionKeys.UPDATE);
1666
1667 if (Validator.isNotNull(themeId)) {
1668 pluginSettingLocalService.checkPermission(
1669 getUserId(), themeId, Plugin.TYPE_THEME);
1670 }
1671
1672 return layoutLocalService.updateLookAndFeel(
1673 groupId, privateLayout, layoutId, themeId, colorSchemeId, css,
1674 wapTheme);
1675 }
1676
1677
1689 @Override
1690 public Layout updateName(
1691 long groupId, boolean privateLayout, long layoutId, String name,
1692 String languageId)
1693 throws PortalException {
1694
1695 LayoutPermissionUtil.check(
1696 getPermissionChecker(), groupId, privateLayout, layoutId,
1697 ActionKeys.UPDATE);
1698
1699 return layoutLocalService.updateName(
1700 groupId, privateLayout, layoutId, name, languageId);
1701 }
1702
1703
1712 @Override
1713 public Layout updateName(long plid, String name, String languageId)
1714 throws PortalException {
1715
1716 LayoutPermissionUtil.check(
1717 getPermissionChecker(), plid, ActionKeys.UPDATE);
1718
1719 return layoutLocalService.updateName(plid, name, languageId);
1720 }
1721
1722
1733 @Override
1734 public Layout updateParentLayoutId(
1735 long groupId, boolean privateLayout, long layoutId,
1736 long parentLayoutId)
1737 throws PortalException {
1738
1739 LayoutPermissionUtil.check(
1740 getPermissionChecker(), groupId, privateLayout, layoutId,
1741 ActionKeys.UPDATE);
1742
1743 return layoutLocalService.updateParentLayoutId(
1744 groupId, privateLayout, layoutId, parentLayoutId);
1745 }
1746
1747
1757 @Override
1758 public Layout updateParentLayoutId(long plid, long parentPlid)
1759 throws PortalException {
1760
1761 LayoutPermissionUtil.check(
1762 getPermissionChecker(), plid, ActionKeys.UPDATE);
1763
1764 return layoutLocalService.updateParentLayoutId(plid, parentPlid);
1765 }
1766
1767
1775 @Override
1776 public Layout updateParentLayoutIdAndPriority(
1777 long plid, long parentPlid, int priority)
1778 throws PortalException {
1779
1780 return layoutLocalService.updateParentLayoutIdAndPriority(
1781 plid, parentPlid, priority);
1782 }
1783
1784
1794 @Override
1795 public Layout updatePriority(
1796 long groupId, boolean privateLayout, long layoutId, int priority)
1797 throws PortalException {
1798
1799 LayoutPermissionUtil.check(
1800 getPermissionChecker(), groupId, privateLayout, layoutId,
1801 ActionKeys.UPDATE);
1802
1803 return layoutLocalService.updatePriority(
1804 groupId, privateLayout, layoutId, priority);
1805 }
1806
1807
1819 @Override
1820 public Layout updatePriority(
1821 long groupId, boolean privateLayout, long layoutId,
1822 long nextLayoutId, long previousLayoutId)
1823 throws PortalException {
1824
1825 LayoutPermissionUtil.check(
1826 getPermissionChecker(), groupId, privateLayout, layoutId,
1827 ActionKeys.UPDATE);
1828
1829 return layoutLocalService.updatePriority(
1830 groupId, privateLayout, layoutId, nextLayoutId, previousLayoutId);
1831 }
1832
1833
1840 @Override
1841 public Layout updatePriority(long plid, int priority)
1842 throws PortalException {
1843
1844 LayoutPermissionUtil.check(
1845 getPermissionChecker(), plid, ActionKeys.UPDATE);
1846
1847 return layoutLocalService.updatePriority(plid, priority);
1848 }
1849
1850
1855 @Deprecated
1856 @Override
1857 public MissingReferences validateImportLayoutsFile(
1858 ExportImportConfiguration exportImportConfiguration, File file)
1859 throws PortalException {
1860
1861 Map<String, Serializable> settingsMap =
1862 exportImportConfiguration.getSettingsMap();
1863
1864 long targetGroupId = MapUtil.getLong(settingsMap, "targetGroupId");
1865
1866 GroupPermissionUtil.check(
1867 getPermissionChecker(), targetGroupId,
1868 ActionKeys.EXPORT_IMPORT_LAYOUTS);
1869
1870 return layoutLocalService.validateImportLayoutsFile(
1871 exportImportConfiguration, file);
1872 }
1873
1874
1879 @Deprecated
1880 @Override
1881 public MissingReferences validateImportLayoutsFile(
1882 ExportImportConfiguration exportImportConfiguration,
1883 InputStream inputStream)
1884 throws PortalException {
1885
1886 Map<String, Serializable> settingsMap =
1887 exportImportConfiguration.getSettingsMap();
1888
1889 long targetGroupId = MapUtil.getLong(settingsMap, "targetGroupId");
1890
1891 GroupPermissionUtil.check(
1892 getPermissionChecker(), targetGroupId,
1893 ActionKeys.EXPORT_IMPORT_LAYOUTS);
1894
1895 return layoutLocalService.validateImportLayoutsFile(
1896 exportImportConfiguration, inputStream);
1897 }
1898
1899
1902 @Deprecated
1903 @Override
1904 public MissingReferences validateImportLayoutsFile(
1905 long groupId, boolean privateLayout,
1906 Map<String, String[]> parameterMap, File file)
1907 throws PortalException {
1908
1909 GroupPermissionUtil.check(
1910 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
1911
1912 return layoutLocalService.validateImportLayoutsFile(
1913 getUserId(), groupId, privateLayout, parameterMap, file);
1914 }
1915
1916
1919 @Deprecated
1920 @Override
1921 public MissingReferences validateImportLayoutsFile(
1922 long groupId, boolean privateLayout,
1923 Map<String, String[]> parameterMap, InputStream inputStream)
1924 throws PortalException {
1925
1926 GroupPermissionUtil.check(
1927 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
1928
1929 return layoutLocalService.validateImportLayoutsFile(
1930 getUserId(), groupId, privateLayout, parameterMap, inputStream);
1931 }
1932
1933
1938 @Deprecated
1939 @Override
1940 public MissingReferences validateImportPortletInfo(
1941 ExportImportConfiguration exportImportConfiguration, File file)
1942 throws PortalException {
1943
1944 Map<String, Serializable> settingsMap =
1945 exportImportConfiguration.getSettingsMap();
1946
1947 long targetPlid = MapUtil.getLong(settingsMap, "targetPlid");
1948 String portletId = MapUtil.getString(settingsMap, "portletId");
1949
1950 PortletPermissionUtil.check(
1951 getPermissionChecker(), targetPlid, portletId,
1952 ActionKeys.CONFIGURATION);
1953
1954 return layoutLocalService.validateImportPortletInfo(
1955 exportImportConfiguration, file);
1956 }
1957
1958
1963 @Deprecated
1964 @Override
1965 public MissingReferences validateImportPortletInfo(
1966 ExportImportConfiguration exportImportConfiguration,
1967 InputStream inputStream)
1968 throws PortalException {
1969
1970 Map<String, Serializable> settingsMap =
1971 exportImportConfiguration.getSettingsMap();
1972
1973 long targetPlid = MapUtil.getLong(settingsMap, "targetPlid");
1974 String portletId = MapUtil.getString(settingsMap, "portletId");
1975
1976 PortletPermissionUtil.check(
1977 getPermissionChecker(), targetPlid, portletId,
1978 ActionKeys.CONFIGURATION);
1979
1980 return layoutLocalService.validateImportPortletInfo(
1981 exportImportConfiguration, inputStream);
1982 }
1983
1984
1987 @Deprecated
1988 @Override
1989 public MissingReferences validateImportPortletInfo(
1990 long plid, long groupId, String portletId,
1991 Map<String, String[]> parameterMap, File file)
1992 throws PortalException {
1993
1994 PortletPermissionUtil.check(
1995 getPermissionChecker(), plid, portletId, ActionKeys.CONFIGURATION);
1996
1997 return layoutLocalService.validateImportPortletInfo(
1998 getUserId(), plid, groupId, portletId, parameterMap, file);
1999 }
2000
2001
2004 @Deprecated
2005 @Override
2006 public MissingReferences validateImportPortletInfo(
2007 long plid, long groupId, String portletId,
2008 Map<String, String[]> parameterMap, InputStream inputStream)
2009 throws PortalException {
2010
2011 PortletPermissionUtil.check(
2012 getPermissionChecker(), plid, portletId, ActionKeys.CONFIGURATION);
2013
2014 return layoutLocalService.validateImportPortletInfo(
2015 getUserId(), plid, groupId, portletId, parameterMap, inputStream);
2016 }
2017
2018 protected List<Layout> filterLayouts(List<Layout> layouts)
2019 throws PortalException {
2020
2021 List<Layout> filteredLayouts = new ArrayList<>();
2022
2023 for (Layout layout : layouts) {
2024 if (LayoutPermissionUtil.contains(
2025 getPermissionChecker(), layout, ActionKeys.VIEW)) {
2026
2027 filteredLayouts.add(layout);
2028 }
2029 }
2030
2031 return filteredLayouts;
2032 }
2033
2034 }