001
014
015 package com.liferay.portal.service.impl;
016
017 import com.liferay.exportimport.kernel.configuration.ExportImportConfigurationConstants;
018 import com.liferay.exportimport.kernel.configuration.ExportImportConfigurationSettingsMapFactory;
019 import com.liferay.exportimport.kernel.lar.ExportImportHelperUtil;
020 import com.liferay.exportimport.kernel.lar.MissingReferences;
021 import com.liferay.exportimport.kernel.model.ExportImportConfiguration;
022 import com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable;
023 import com.liferay.portal.kernel.exception.NoSuchLayoutException;
024 import com.liferay.portal.kernel.exception.PortalException;
025 import com.liferay.portal.kernel.messaging.DestinationNames;
026 import com.liferay.portal.kernel.model.Group;
027 import com.liferay.portal.kernel.model.Layout;
028 import com.liferay.portal.kernel.model.LayoutConstants;
029 import com.liferay.portal.kernel.model.LayoutReference;
030 import com.liferay.portal.kernel.model.LayoutTypePortlet;
031 import com.liferay.portal.kernel.model.Plugin;
032 import com.liferay.portal.kernel.model.User;
033 import com.liferay.portal.kernel.portlet.PortletPreferencesFactoryUtil;
034 import com.liferay.portal.kernel.repository.model.FileEntry;
035 import com.liferay.portal.kernel.scheduler.SchedulerEngineHelperUtil;
036 import com.liferay.portal.kernel.scheduler.StorageType;
037 import com.liferay.portal.kernel.scheduler.Trigger;
038 import com.liferay.portal.kernel.scheduler.TriggerFactoryUtil;
039 import com.liferay.portal.kernel.security.permission.ActionKeys;
040 import com.liferay.portal.kernel.security.permission.PermissionChecker;
041 import com.liferay.portal.kernel.service.ServiceContext;
042 import com.liferay.portal.kernel.service.permission.GroupPermissionUtil;
043 import com.liferay.portal.kernel.service.permission.LayoutPermissionUtil;
044 import com.liferay.portal.kernel.service.permission.PortletPermissionUtil;
045 import com.liferay.portal.kernel.util.Digester;
046 import com.liferay.portal.kernel.util.DigesterUtil;
047 import com.liferay.portal.kernel.util.GetterUtil;
048 import com.liferay.portal.kernel.util.MapUtil;
049 import com.liferay.portal.kernel.util.PortletKeys;
050 import com.liferay.portal.kernel.util.TempFileEntryUtil;
051 import com.liferay.portal.kernel.util.Validator;
052 import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
053 import com.liferay.portal.service.base.LayoutServiceBaseImpl;
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
1656 @Override
1657 public Layout updateLookAndFeel(
1658 long groupId, boolean privateLayout, long layoutId, String themeId,
1659 String colorSchemeId, String css)
1660 throws PortalException {
1661
1662 LayoutPermissionUtil.check(
1663 getPermissionChecker(), groupId, privateLayout, layoutId,
1664 ActionKeys.UPDATE);
1665
1666 if (Validator.isNotNull(themeId)) {
1667 pluginSettingLocalService.checkPermission(
1668 getUserId(), themeId, Plugin.TYPE_THEME);
1669 }
1670
1671 return layoutLocalService.updateLookAndFeel(
1672 groupId, privateLayout, layoutId, themeId, colorSchemeId, css);
1673 }
1674
1675
1687 @Override
1688 public Layout updateName(
1689 long groupId, boolean privateLayout, long layoutId, String name,
1690 String languageId)
1691 throws PortalException {
1692
1693 LayoutPermissionUtil.check(
1694 getPermissionChecker(), groupId, privateLayout, layoutId,
1695 ActionKeys.UPDATE);
1696
1697 return layoutLocalService.updateName(
1698 groupId, privateLayout, layoutId, name, languageId);
1699 }
1700
1701
1710 @Override
1711 public Layout updateName(long plid, String name, String languageId)
1712 throws PortalException {
1713
1714 LayoutPermissionUtil.check(
1715 getPermissionChecker(), plid, ActionKeys.UPDATE);
1716
1717 return layoutLocalService.updateName(plid, name, languageId);
1718 }
1719
1720
1731 @Override
1732 public Layout updateParentLayoutId(
1733 long groupId, boolean privateLayout, long layoutId,
1734 long parentLayoutId)
1735 throws PortalException {
1736
1737 LayoutPermissionUtil.check(
1738 getPermissionChecker(), groupId, privateLayout, layoutId,
1739 ActionKeys.UPDATE);
1740
1741 return layoutLocalService.updateParentLayoutId(
1742 groupId, privateLayout, layoutId, parentLayoutId);
1743 }
1744
1745
1755 @Override
1756 public Layout updateParentLayoutId(long plid, long parentPlid)
1757 throws PortalException {
1758
1759 LayoutPermissionUtil.check(
1760 getPermissionChecker(), plid, ActionKeys.UPDATE);
1761
1762 return layoutLocalService.updateParentLayoutId(plid, parentPlid);
1763 }
1764
1765
1773 @Override
1774 public Layout updateParentLayoutIdAndPriority(
1775 long plid, long parentPlid, int priority)
1776 throws PortalException {
1777
1778 return layoutLocalService.updateParentLayoutIdAndPriority(
1779 plid, parentPlid, priority);
1780 }
1781
1782
1792 @Override
1793 public Layout updatePriority(
1794 long groupId, boolean privateLayout, long layoutId, int priority)
1795 throws PortalException {
1796
1797 LayoutPermissionUtil.check(
1798 getPermissionChecker(), groupId, privateLayout, layoutId,
1799 ActionKeys.UPDATE);
1800
1801 return layoutLocalService.updatePriority(
1802 groupId, privateLayout, layoutId, priority);
1803 }
1804
1805
1817 @Override
1818 public Layout updatePriority(
1819 long groupId, boolean privateLayout, long layoutId,
1820 long nextLayoutId, long previousLayoutId)
1821 throws PortalException {
1822
1823 LayoutPermissionUtil.check(
1824 getPermissionChecker(), groupId, privateLayout, layoutId,
1825 ActionKeys.UPDATE);
1826
1827 return layoutLocalService.updatePriority(
1828 groupId, privateLayout, layoutId, nextLayoutId, previousLayoutId);
1829 }
1830
1831
1838 @Override
1839 public Layout updatePriority(long plid, int priority)
1840 throws PortalException {
1841
1842 LayoutPermissionUtil.check(
1843 getPermissionChecker(), plid, ActionKeys.UPDATE);
1844
1845 return layoutLocalService.updatePriority(plid, priority);
1846 }
1847
1848
1853 @Deprecated
1854 @Override
1855 public MissingReferences validateImportLayoutsFile(
1856 ExportImportConfiguration exportImportConfiguration, File file)
1857 throws PortalException {
1858
1859 Map<String, Serializable> settingsMap =
1860 exportImportConfiguration.getSettingsMap();
1861
1862 long targetGroupId = MapUtil.getLong(settingsMap, "targetGroupId");
1863
1864 GroupPermissionUtil.check(
1865 getPermissionChecker(), targetGroupId,
1866 ActionKeys.EXPORT_IMPORT_LAYOUTS);
1867
1868 return layoutLocalService.validateImportLayoutsFile(
1869 exportImportConfiguration, file);
1870 }
1871
1872
1877 @Deprecated
1878 @Override
1879 public MissingReferences validateImportLayoutsFile(
1880 ExportImportConfiguration exportImportConfiguration,
1881 InputStream inputStream)
1882 throws PortalException {
1883
1884 Map<String, Serializable> settingsMap =
1885 exportImportConfiguration.getSettingsMap();
1886
1887 long targetGroupId = MapUtil.getLong(settingsMap, "targetGroupId");
1888
1889 GroupPermissionUtil.check(
1890 getPermissionChecker(), targetGroupId,
1891 ActionKeys.EXPORT_IMPORT_LAYOUTS);
1892
1893 return layoutLocalService.validateImportLayoutsFile(
1894 exportImportConfiguration, inputStream);
1895 }
1896
1897
1900 @Deprecated
1901 @Override
1902 public MissingReferences validateImportLayoutsFile(
1903 long groupId, boolean privateLayout,
1904 Map<String, String[]> parameterMap, File file)
1905 throws PortalException {
1906
1907 GroupPermissionUtil.check(
1908 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
1909
1910 return layoutLocalService.validateImportLayoutsFile(
1911 getUserId(), groupId, privateLayout, parameterMap, file);
1912 }
1913
1914
1917 @Deprecated
1918 @Override
1919 public MissingReferences validateImportLayoutsFile(
1920 long groupId, boolean privateLayout,
1921 Map<String, String[]> parameterMap, InputStream inputStream)
1922 throws PortalException {
1923
1924 GroupPermissionUtil.check(
1925 getPermissionChecker(), groupId, ActionKeys.EXPORT_IMPORT_LAYOUTS);
1926
1927 return layoutLocalService.validateImportLayoutsFile(
1928 getUserId(), groupId, privateLayout, parameterMap, inputStream);
1929 }
1930
1931
1936 @Deprecated
1937 @Override
1938 public MissingReferences validateImportPortletInfo(
1939 ExportImportConfiguration exportImportConfiguration, File file)
1940 throws PortalException {
1941
1942 Map<String, Serializable> settingsMap =
1943 exportImportConfiguration.getSettingsMap();
1944
1945 long targetPlid = MapUtil.getLong(settingsMap, "targetPlid");
1946 String portletId = MapUtil.getString(settingsMap, "portletId");
1947
1948 PortletPermissionUtil.check(
1949 getPermissionChecker(), targetPlid, portletId,
1950 ActionKeys.CONFIGURATION);
1951
1952 return layoutLocalService.validateImportPortletInfo(
1953 exportImportConfiguration, file);
1954 }
1955
1956
1961 @Deprecated
1962 @Override
1963 public MissingReferences validateImportPortletInfo(
1964 ExportImportConfiguration exportImportConfiguration,
1965 InputStream inputStream)
1966 throws PortalException {
1967
1968 Map<String, Serializable> settingsMap =
1969 exportImportConfiguration.getSettingsMap();
1970
1971 long targetPlid = MapUtil.getLong(settingsMap, "targetPlid");
1972 String portletId = MapUtil.getString(settingsMap, "portletId");
1973
1974 PortletPermissionUtil.check(
1975 getPermissionChecker(), targetPlid, portletId,
1976 ActionKeys.CONFIGURATION);
1977
1978 return layoutLocalService.validateImportPortletInfo(
1979 exportImportConfiguration, inputStream);
1980 }
1981
1982
1985 @Deprecated
1986 @Override
1987 public MissingReferences validateImportPortletInfo(
1988 long plid, long groupId, String portletId,
1989 Map<String, String[]> parameterMap, File file)
1990 throws PortalException {
1991
1992 PortletPermissionUtil.check(
1993 getPermissionChecker(), plid, portletId, ActionKeys.CONFIGURATION);
1994
1995 return layoutLocalService.validateImportPortletInfo(
1996 getUserId(), plid, groupId, portletId, parameterMap, file);
1997 }
1998
1999
2002 @Deprecated
2003 @Override
2004 public MissingReferences validateImportPortletInfo(
2005 long plid, long groupId, String portletId,
2006 Map<String, String[]> parameterMap, InputStream inputStream)
2007 throws PortalException {
2008
2009 PortletPermissionUtil.check(
2010 getPermissionChecker(), plid, portletId, ActionKeys.CONFIGURATION);
2011
2012 return layoutLocalService.validateImportPortletInfo(
2013 getUserId(), plid, groupId, portletId, parameterMap, inputStream);
2014 }
2015
2016 protected List<Layout> filterLayouts(List<Layout> layouts)
2017 throws PortalException {
2018
2019 List<Layout> filteredLayouts = new ArrayList<>();
2020
2021 for (Layout layout : layouts) {
2022 if (LayoutPermissionUtil.contains(
2023 getPermissionChecker(), layout, ActionKeys.VIEW)) {
2024
2025 filteredLayouts.add(layout);
2026 }
2027 }
2028
2029 return filteredLayouts;
2030 }
2031
2032 }