001
014
015 package com.liferay.portal.service.impl;
016
017 import com.liferay.portal.NoSuchGroupException;
018 import com.liferay.portal.kernel.dao.orm.QueryUtil;
019 import com.liferay.portal.kernel.exception.PortalException;
020 import com.liferay.portal.kernel.util.ArrayUtil;
021 import com.liferay.portal.kernel.util.ListUtil;
022 import com.liferay.portal.kernel.util.LocaleUtil;
023 import com.liferay.portal.kernel.util.MapUtil;
024 import com.liferay.portal.kernel.util.OrderByComparator;
025 import com.liferay.portal.kernel.util.UnicodeProperties;
026 import com.liferay.portal.model.Company;
027 import com.liferay.portal.model.Group;
028 import com.liferay.portal.model.GroupConstants;
029 import com.liferay.portal.model.Organization;
030 import com.liferay.portal.model.Portlet;
031 import com.liferay.portal.model.User;
032 import com.liferay.portal.model.UserGroup;
033 import com.liferay.portal.security.auth.PrincipalException;
034 import com.liferay.portal.security.membershippolicy.SiteMembershipPolicyUtil;
035 import com.liferay.portal.security.permission.ActionKeys;
036 import com.liferay.portal.security.permission.PermissionChecker;
037 import com.liferay.portal.security.permission.UserBag;
038 import com.liferay.portal.security.permission.UserBagFactoryUtil;
039 import com.liferay.portal.service.ServiceContext;
040 import com.liferay.portal.service.base.GroupServiceBaseImpl;
041 import com.liferay.portal.service.permission.GroupPermissionUtil;
042 import com.liferay.portal.service.permission.PortalPermissionUtil;
043 import com.liferay.portal.service.permission.PortletPermissionUtil;
044 import com.liferay.portal.service.permission.RolePermissionUtil;
045 import com.liferay.portal.service.permission.UserPermissionUtil;
046 import com.liferay.portal.util.PortalUtil;
047 import com.liferay.portal.util.PortletKeys;
048 import com.liferay.portal.util.PropsValues;
049 import com.liferay.portlet.asset.model.AssetCategory;
050 import com.liferay.portlet.asset.model.AssetTag;
051 import com.liferay.portlet.expando.model.ExpandoBridge;
052 import com.liferay.portlet.exportimport.staging.StagingUtil;
053 import com.liferay.portlet.ratings.transformer.RatingsDataTransformerUtil;
054
055 import java.io.Serializable;
056
057 import java.util.ArrayList;
058 import java.util.Collection;
059 import java.util.Collections;
060 import java.util.HashMap;
061 import java.util.Iterator;
062 import java.util.LinkedHashMap;
063 import java.util.LinkedHashSet;
064 import java.util.List;
065 import java.util.Locale;
066 import java.util.Map;
067 import java.util.Set;
068
069
078 public class GroupServiceImpl extends GroupServiceBaseImpl {
079
080 @Override
081 public Group addGroup(
082 long parentGroupId, long liveGroupId, Map<Locale, String> nameMap,
083 Map<Locale, String> descriptionMap, int type,
084 boolean manualMembership, int membershipRestriction,
085 String friendlyURL, boolean site, boolean inheritContent,
086 boolean active, ServiceContext serviceContext)
087 throws PortalException {
088
089 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
090 PortalPermissionUtil.check(
091 getPermissionChecker(), ActionKeys.ADD_COMMUNITY);
092 }
093 else {
094 GroupPermissionUtil.check(
095 getPermissionChecker(), parentGroupId,
096 ActionKeys.ADD_COMMUNITY);
097 }
098
099 Group group = groupLocalService.addGroup(
100 getUserId(), parentGroupId, null, 0, liveGroupId, nameMap,
101 descriptionMap, type, manualMembership, membershipRestriction,
102 friendlyURL, site, inheritContent, active, serviceContext);
103
104 if (site) {
105 SiteMembershipPolicyUtil.verifyPolicy(group);
106 }
107
108 return group;
109 }
110
111 @Override
112 public Group addGroup(
113 long parentGroupId, long liveGroupId, Map<Locale, String> nameMap,
114 Map<Locale, String> descriptionMap, int type,
115 boolean manualMembership, int membershipRestriction,
116 String friendlyURL, boolean site, boolean active,
117 ServiceContext serviceContext)
118 throws PortalException {
119
120 return addGroup(
121 parentGroupId, liveGroupId, nameMap, descriptionMap, type,
122 manualMembership, membershipRestriction, friendlyURL, site, false,
123 active, serviceContext);
124 }
125
126
153 @Deprecated
154 @Override
155 public Group addGroup(
156 long parentGroupId, long liveGroupId, String name,
157 String description, int type, boolean manualMembership,
158 int membershipRestriction, String friendlyURL, boolean site,
159 boolean active, ServiceContext serviceContext)
160 throws PortalException {
161
162 return addGroup(
163 parentGroupId, liveGroupId, getLocalizationMap(name),
164 getLocalizationMap(description), type, manualMembership,
165 membershipRestriction, friendlyURL, site, false, active,
166 serviceContext);
167 }
168
169
190 @Deprecated
191 @Override
192 public Group addGroup(
193 long parentGroupId, String name, String description, int type,
194 String friendlyURL, boolean site, boolean active,
195 ServiceContext serviceContext)
196 throws PortalException {
197
198 return addGroup(
199 parentGroupId, GroupConstants.DEFAULT_LIVE_GROUP_ID,
200 getLocalizationMap(name), getLocalizationMap(description), type,
201 true, GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL,
202 site, active, serviceContext);
203 }
204
205
209 @Deprecated
210 @Override
211 public Group addGroup(
212 String name, String description, int type, String friendlyURL,
213 boolean site, boolean active, ServiceContext serviceContext)
214 throws PortalException {
215
216 return addGroup(
217 GroupConstants.DEFAULT_PARENT_GROUP_ID, name, description, type,
218 friendlyURL, site, active, serviceContext);
219 }
220
221
227 @Override
228 public void addRoleGroups(long roleId, long[] groupIds)
229 throws PortalException {
230
231 RolePermissionUtil.check(
232 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
233
234 groupLocalService.addRoleGroups(roleId, groupIds);
235 }
236
237
243 @Override
244 public void checkRemoteStagingGroup(long groupId) throws PortalException {
245 Group group = getGroup(groupId);
246
247 PermissionChecker permissionChecker = getPermissionChecker();
248
249 if (group.getCompanyId() != permissionChecker.getCompanyId()) {
250 throw new NoSuchGroupException(
251 "Group " + groupId + " does not belong in company " +
252 permissionChecker.getCompanyId());
253 }
254 }
255
256
268 @Override
269 public void deleteGroup(long groupId) throws PortalException {
270 GroupPermissionUtil.check(
271 getPermissionChecker(), groupId, ActionKeys.DELETE);
272
273 groupLocalService.deleteGroup(groupId);
274 }
275
276 @Override
277 public void disableStaging(long groupId) throws PortalException {
278 Group group = groupLocalService.getGroup(groupId);
279
280 GroupPermissionUtil.check(
281 getPermissionChecker(), group, ActionKeys.UPDATE);
282
283 groupLocalService.disableStaging(groupId);
284 }
285
286 @Override
287 public void enableStaging(long groupId) throws PortalException {
288 Group group = groupLocalService.getGroup(groupId);
289
290 GroupPermissionUtil.check(
291 getPermissionChecker(), group, ActionKeys.UPDATE);
292
293 groupLocalService.enableStaging(groupId);
294 }
295
296
302 @Override
303 public Group getCompanyGroup(long companyId) throws PortalException {
304 Group group = groupLocalService.getCompanyGroup(companyId);
305
306 GroupPermissionUtil.check(
307 getPermissionChecker(), group, ActionKeys.VIEW);
308
309 return group;
310 }
311
312
318 @Override
319 public Group getGroup(long groupId) throws PortalException {
320 Group group = groupLocalService.getGroup(groupId);
321
322 GroupPermissionUtil.check(
323 getPermissionChecker(), group, ActionKeys.VIEW);
324
325 return group;
326 }
327
328
335 @Override
336 public Group getGroup(long companyId, String groupKey)
337 throws PortalException {
338
339 Group group = groupLocalService.getGroup(companyId, groupKey);
340
341 GroupPermissionUtil.check(
342 getPermissionChecker(), group, ActionKeys.VIEW);
343
344 return group;
345 }
346
347 @Override
348 public String getGroupDisplayURL(
349 long groupId, boolean privateLayout, boolean secureConnection)
350 throws PortalException {
351
352 Group group = groupLocalService.getGroup(groupId);
353
354 GroupPermissionUtil.check(
355 getPermissionChecker(), group, ActionKeys.VIEW);
356
357 if (!privateLayout && (group.getPublicLayoutsPageCount() > 0)) {
358 return PortalUtil.getLayoutSetDisplayURL(
359 group.getPublicLayoutSet(), secureConnection);
360 }
361 else if (privateLayout && (group.getPrivateLayoutsPageCount() > 0)) {
362 return PortalUtil.getLayoutSetDisplayURL(
363 group.getPrivateLayoutSet(), secureConnection);
364 }
365
366 GroupPermissionUtil.check(
367 getPermissionChecker(), group, ActionKeys.UPDATE);
368
369 return PortalUtil.getControlPanelFullURL(
370 groupId, PortletKeys.LAYOUTS_ADMIN, null);
371 }
372
373
382 @Override
383 public List<Group> getGroups(
384 long companyId, long parentGroupId, boolean site)
385 throws PortalException {
386
387 return filterGroups(
388 groupLocalService.getGroups(companyId, parentGroupId, site));
389 }
390
391
401 @Override
402 public List<Group> getManageableSiteGroups(
403 Collection<Portlet> portlets, int max)
404 throws PortalException {
405
406 PermissionChecker permissionChecker = getPermissionChecker();
407
408 if (permissionChecker.isCompanyAdmin()) {
409 LinkedHashMap<String, Object> params = new LinkedHashMap<>();
410
411 params.put("site", Boolean.TRUE);
412
413 return ListUtil.unique(
414 groupLocalService.search(
415 permissionChecker.getCompanyId(), null, null, null, params,
416 true, 0, max));
417 }
418
419 Set<Group> groups = new LinkedHashSet<>();
420
421 List<Group> userSitesGroups = getUserSitesGroups(null, max);
422
423 Iterator<Group> itr = userSitesGroups.iterator();
424
425 while (itr.hasNext()) {
426 Group group = itr.next();
427
428 if (group.isSite() &&
429 PortletPermissionUtil.hasControlPanelAccessPermission(
430 permissionChecker, group.getGroupId(), portlets)) {
431
432 groups.add(group);
433 }
434 }
435
436 return new ArrayList<>(groups);
437 }
438
439
451 @Deprecated
452 @Override
453 public List<Group> getManageableSites(Collection<Portlet> portlets, int max)
454 throws PortalException {
455
456 return getManageableSiteGroups(portlets, max);
457 }
458
459
465 @Override
466 public List<Group> getOrganizationsGroups(List<Organization> organizations)
467 throws PortalException {
468
469 List<Group> groups = groupLocalService.getOrganizationsGroups(
470 organizations);
471
472 return filterGroups(groups);
473 }
474
475
482 @Override
483 public Group getUserGroup(long companyId, long userId)
484 throws PortalException {
485
486 Group group = groupLocalService.getUserGroup(companyId, userId);
487
488 GroupPermissionUtil.check(
489 getPermissionChecker(), group, ActionKeys.VIEW);
490
491 return group;
492 }
493
494
500 @Override
501 public List<Group> getUserGroupsGroups(List<UserGroup> userGroups)
502 throws PortalException {
503
504 List<Group> groups = groupLocalService.getUserGroupsGroups(userGroups);
505
506 return filterGroups(groups);
507 }
508
509
530 @Override
531 public List<Group> getUserOrganizationsGroups(
532 long userId, int start, int end)
533 throws PortalException {
534
535 List<Group> groups = groupLocalService.getUserOrganizationsGroups(
536 userId, start, end);
537
538 return filterGroups(groups);
539 }
540
541
545 @Deprecated
546 @Override
547 public List<Group> getUserPlaces(
548 long userId, String[] classNames, boolean includeControlPanel,
549 int max)
550 throws PortalException {
551
552 return getUserSitesGroups(userId, classNames, max);
553 }
554
555
589 @Deprecated
590 @Override
591 public List<Group> getUserPlaces(long userId, String[] classNames, int max)
592 throws PortalException {
593
594 return getUserSitesGroups(userId, classNames, max);
595 }
596
597
630 @Deprecated
631 @Override
632 public List<Group> getUserPlaces(String[] classNames, int max)
633 throws PortalException {
634
635 return getUserSitesGroups(classNames, max);
636 }
637
638
647 @Deprecated
648 @Override
649 public int getUserPlacesCount() throws PortalException {
650 return getUserSitesGroupsCount();
651 }
652
653
661 @Deprecated
662 @Override
663 public List<Group> getUserSites() throws PortalException {
664 return getUserSitesGroups();
665 }
666
667 @Override
668 public List<Group> getUserSitesGroups() throws PortalException {
669 return getUserSitesGroups(null, QueryUtil.ALL_POS);
670 }
671
672
704 @Override
705 public List<Group> getUserSitesGroups(
706 long userId, String[] classNames, int max)
707 throws PortalException {
708
709 User user = userPersistence.findByPrimaryKey(userId);
710
711 if (user.isDefaultUser()) {
712 return Collections.emptyList();
713 }
714
715 Set<Group> userSiteGroups = new LinkedHashSet<>();
716
717 if (classNames == null) {
718 classNames = new String[] {
719 Company.class.getName(), Group.class.getName(),
720 Organization.class.getName(), User.class.getName()
721 };
722 }
723
724 if (ArrayUtil.contains(classNames, User.class.getName())) {
725 if (PropsValues.LAYOUT_USER_PRIVATE_LAYOUTS_ENABLED ||
726 PropsValues.LAYOUT_USER_PUBLIC_LAYOUTS_ENABLED) {
727
728 userSiteGroups.add(user.getGroup());
729
730 if (userSiteGroups.size() == max) {
731 return new ArrayList<>(userSiteGroups);
732 }
733 }
734 }
735
736 if (ArrayUtil.contains(classNames, Company.class.getName())) {
737 userSiteGroups.add(
738 groupLocalService.getCompanyGroup(user.getCompanyId()));
739
740 if (userSiteGroups.size() == max) {
741 return new ArrayList<>(userSiteGroups);
742 }
743 }
744
745 if (ArrayUtil.contains(classNames, Group.class.getName()) ||
746 ArrayUtil.contains(classNames, Organization.class.getName())) {
747
748 UserBag userBag = UserBagFactoryUtil.create(userId);
749
750 if (ArrayUtil.contains(classNames, Group.class.getName())) {
751 for (Group group : userBag.getUserGroups()) {
752 if (group.isActive() && group.isSite()) {
753 if (userSiteGroups.add(group) &&
754 (userSiteGroups.size() == max)) {
755
756 return new ArrayList<>(userSiteGroups);
757 }
758 }
759 }
760 }
761
762 if (ArrayUtil.contains(classNames, Organization.class.getName())) {
763 for (Group group : userBag.getUserOrgGroups()) {
764 if (group.isActive() && group.isSite()) {
765 if (userSiteGroups.add(group) &&
766 (userSiteGroups.size() == max)) {
767
768 return new ArrayList<>(userSiteGroups);
769 }
770 }
771 }
772 }
773 }
774
775 return new ArrayList<>(userSiteGroups);
776 }
777
778
809 @Override
810 public List<Group> getUserSitesGroups(String[] classNames, int max)
811 throws PortalException {
812
813 return getUserSitesGroups(getGuestOrUserId(), classNames, max);
814 }
815
816
824 @Override
825 public int getUserSitesGroupsCount() throws PortalException {
826 List<Group> userSitesGroups = getUserSitesGroups(
827 getGuestOrUserId(), null, QueryUtil.ALL_POS);
828
829 return userSitesGroups.size();
830 }
831
832
842 @Override
843 public boolean hasUserGroup(long userId, long groupId)
844 throws PortalException {
845
846 try {
847 UserPermissionUtil.check(
848 getPermissionChecker(), userId, ActionKeys.VIEW);
849 }
850 catch (PrincipalException pe) {
851 GroupPermissionUtil.check(
852 getPermissionChecker(), groupId, ActionKeys.VIEW_MEMBERS);
853 }
854
855 return groupLocalService.hasUserGroup(userId, groupId);
856 }
857
858 @Override
859 public List<Group> search(
860 long companyId, long[] classNameIds, String keywords,
861 LinkedHashMap<String, Object> params, int start, int end,
862 OrderByComparator<Group> obc)
863 throws PortalException {
864
865 List<Group> groups = groupLocalService.search(
866 companyId, classNameIds, keywords, params, start, end, obc);
867
868 return filterGroups(groups);
869 }
870
871 @Override
872 public List<Group> search(
873 long companyId, long[] classNameIds, String name,
874 String description, LinkedHashMap<String, Object> params,
875 boolean andOperator, int start, int end,
876 OrderByComparator<Group> obc)
877 throws PortalException {
878
879 List<Group> groups = groupLocalService.search(
880 companyId, classNameIds, name, description, params, andOperator,
881 start, end, obc);
882
883 return filterGroups(groups);
884 }
885
886
916 @Override
917 public List<Group> search(
918 long companyId, String name, String description, String[] params,
919 int start, int end)
920 throws PortalException {
921
922 if (params == null) {
923 params = new String[0];
924 }
925
926 LinkedHashMap<String, Object> paramsObj = MapUtil.toLinkedHashMap(
927 params);
928
929 List<Group> groups = groupLocalService.search(
930 companyId, name, description, paramsObj, true, start, end);
931
932 return filterGroups(groups);
933 }
934
935
952 @Override
953 public int searchCount(
954 long companyId, String name, String description, String[] params) {
955
956 if (params == null) {
957 params = new String[0];
958 }
959
960 LinkedHashMap<String, Object> paramsObj = MapUtil.toLinkedHashMap(
961 params);
962
963 return groupLocalService.searchCount(
964 companyId, name, description, paramsObj, true);
965 }
966
967
974 @Override
975 public void setRoleGroups(long roleId, long[] groupIds)
976 throws PortalException {
977
978 RolePermissionUtil.check(
979 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
980
981 groupLocalService.setRoleGroups(roleId, groupIds);
982 }
983
984
990 @Override
991 public void unsetRoleGroups(long roleId, long[] groupIds)
992 throws PortalException {
993
994 RolePermissionUtil.check(
995 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
996
997 groupLocalService.unsetRoleGroups(roleId, groupIds);
998 }
999
1000
1008 @Override
1009 public Group updateFriendlyURL(long groupId, String friendlyURL)
1010 throws PortalException {
1011
1012 GroupPermissionUtil.check(
1013 getPermissionChecker(), groupId, ActionKeys.UPDATE);
1014
1015 return groupLocalService.updateFriendlyURL(groupId, friendlyURL);
1016 }
1017
1018 @Override
1019 public Group updateGroup(
1020 long groupId, long parentGroupId, Map<Locale, String> nameMap,
1021 Map<Locale, String> descriptionMap, int type,
1022 boolean manualMembership, int membershipRestriction,
1023 String friendlyURL, boolean inheritContent, boolean active,
1024 ServiceContext serviceContext)
1025 throws PortalException {
1026
1027 Group group = groupPersistence.findByPrimaryKey(groupId);
1028
1029 GroupPermissionUtil.check(
1030 getPermissionChecker(), group, ActionKeys.UPDATE);
1031
1032 if (group.getParentGroupId() != parentGroupId) {
1033 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
1034 PortalPermissionUtil.check(
1035 getPermissionChecker(), ActionKeys.ADD_COMMUNITY);
1036 }
1037 else {
1038 GroupPermissionUtil.check(
1039 getPermissionChecker(), parentGroupId,
1040 ActionKeys.ADD_COMMUNITY);
1041 }
1042 }
1043
1044 if (group.isSite()) {
1045 Group oldGroup = group;
1046
1047 List<AssetCategory> oldAssetCategories =
1048 assetCategoryLocalService.getCategories(
1049 Group.class.getName(), groupId);
1050
1051 List<AssetTag> oldAssetTags = assetTagLocalService.getTags(
1052 Group.class.getName(), groupId);
1053
1054 ExpandoBridge oldExpandoBridge = oldGroup.getExpandoBridge();
1055
1056 Map<String, Serializable> oldExpandoAttributes =
1057 oldExpandoBridge.getAttributes();
1058
1059 group = groupLocalService.updateGroup(
1060 groupId, parentGroupId, nameMap, descriptionMap, type,
1061 manualMembership, membershipRestriction, friendlyURL,
1062 inheritContent, active, serviceContext);
1063
1064 SiteMembershipPolicyUtil.verifyPolicy(
1065 group, oldGroup, oldAssetCategories, oldAssetTags,
1066 oldExpandoAttributes, null);
1067
1068 return group;
1069 }
1070 else {
1071 return groupLocalService.updateGroup(
1072 groupId, parentGroupId, nameMap, descriptionMap, type,
1073 manualMembership, membershipRestriction, friendlyURL,
1074 inheritContent, active, serviceContext);
1075 }
1076 }
1077
1078
1103 @Deprecated
1104 @Override
1105 public Group updateGroup(
1106 long groupId, long parentGroupId, String name, String description,
1107 int type, boolean manualMembership, int membershipRestriction,
1108 String friendlyURL, boolean inheritContent, boolean active,
1109 ServiceContext serviceContext)
1110 throws PortalException {
1111
1112 return updateGroup(
1113 groupId, parentGroupId, getLocalizationMap(name),
1114 getLocalizationMap(description), type, manualMembership,
1115 membershipRestriction, friendlyURL, inheritContent, active,
1116 serviceContext);
1117 }
1118
1119
1127 @Override
1128 public Group updateGroup(long groupId, String typeSettings)
1129 throws PortalException {
1130
1131 Group group = groupPersistence.findByPrimaryKey(groupId);
1132
1133 GroupPermissionUtil.check(
1134 getPermissionChecker(), group, ActionKeys.UPDATE);
1135
1136 if (group.isSite()) {
1137 Group oldGroup = group;
1138
1139 UnicodeProperties oldTypeSettingsProperties =
1140 oldGroup.getTypeSettingsProperties();
1141
1142 group = groupLocalService.updateGroup(groupId, typeSettings);
1143
1144 RatingsDataTransformerUtil.transformGroupRatingsData(
1145 groupId, oldTypeSettingsProperties,
1146 group.getTypeSettingsProperties());
1147
1148 SiteMembershipPolicyUtil.verifyPolicy(
1149 group, oldGroup, null, null, null, oldTypeSettingsProperties);
1150
1151 return group;
1152 }
1153 else {
1154 return groupLocalService.updateGroup(groupId, typeSettings);
1155 }
1156 }
1157
1158 @Override
1159 public void updateStagedPortlets(
1160 long groupId, Map<String, String> stagedPortletIds)
1161 throws PortalException {
1162
1163 Group group = groupPersistence.findByPrimaryKey(groupId);
1164
1165 GroupPermissionUtil.check(
1166 getPermissionChecker(), group, ActionKeys.UPDATE);
1167
1168 UnicodeProperties typeSettingsProperties =
1169 group.getTypeSettingsProperties();
1170
1171 for (String stagedPortletId : stagedPortletIds.keySet()) {
1172 typeSettingsProperties.setProperty(
1173 StagingUtil.getStagedPortletId(stagedPortletId),
1174 stagedPortletIds.get(stagedPortletId));
1175 }
1176
1177 groupLocalService.updateGroup(group);
1178 }
1179
1180 protected List<Group> filterGroups(List<Group> groups)
1181 throws PortalException {
1182
1183 List<Group> filteredGroups = new ArrayList<>();
1184
1185 for (Group group : groups) {
1186 if (GroupPermissionUtil.contains(
1187 getPermissionChecker(), group, ActionKeys.VIEW)) {
1188
1189 filteredGroups.add(group);
1190 }
1191 }
1192
1193 return filteredGroups;
1194 }
1195
1196 protected Map<Locale, String> getLocalizationMap(String value) {
1197 Map<Locale, String> map = new HashMap<>();
1198
1199 map.put(LocaleUtil.getDefault(), value);
1200
1201 return map;
1202 }
1203
1204 }