001
014
015 package com.liferay.portal.service.impl;
016
017 import com.liferay.portal.DuplicateGroupException;
018 import com.liferay.portal.GroupFriendlyURLException;
019 import com.liferay.portal.GroupNameException;
020 import com.liferay.portal.NoSuchGroupException;
021 import com.liferay.portal.NoSuchLayoutSetException;
022 import com.liferay.portal.NoSuchUserException;
023 import com.liferay.portal.RequiredGroupException;
024 import com.liferay.portal.kernel.cache.ThreadLocalCachable;
025 import com.liferay.portal.kernel.dao.orm.QueryUtil;
026 import com.liferay.portal.kernel.exception.PortalException;
027 import com.liferay.portal.kernel.exception.SystemException;
028 import com.liferay.portal.kernel.lar.PortletDataHandlerKeys;
029 import com.liferay.portal.kernel.log.Log;
030 import com.liferay.portal.kernel.log.LogFactoryUtil;
031 import com.liferay.portal.kernel.messaging.DestinationNames;
032 import com.liferay.portal.kernel.scheduler.SchedulerEngineUtil;
033 import com.liferay.portal.kernel.scheduler.StorageType;
034 import com.liferay.portal.kernel.spring.aop.Skip;
035 import com.liferay.portal.kernel.staging.StagingUtil;
036 import com.liferay.portal.kernel.transaction.Propagation;
037 import com.liferay.portal.kernel.transaction.Transactional;
038 import com.liferay.portal.kernel.util.CharPool;
039 import com.liferay.portal.kernel.util.FileUtil;
040 import com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil;
041 import com.liferay.portal.kernel.util.GetterUtil;
042 import com.liferay.portal.kernel.util.OrderByComparator;
043 import com.liferay.portal.kernel.util.ParamUtil;
044 import com.liferay.portal.kernel.util.PropsKeys;
045 import com.liferay.portal.kernel.util.StringPool;
046 import com.liferay.portal.kernel.util.StringUtil;
047 import com.liferay.portal.kernel.util.Validator;
048 import com.liferay.portal.model.Account;
049 import com.liferay.portal.model.Company;
050 import com.liferay.portal.model.Group;
051 import com.liferay.portal.model.GroupConstants;
052 import com.liferay.portal.model.Layout;
053 import com.liferay.portal.model.LayoutConstants;
054 import com.liferay.portal.model.LayoutPrototype;
055 import com.liferay.portal.model.LayoutSet;
056 import com.liferay.portal.model.LayoutSetPrototype;
057 import com.liferay.portal.model.LayoutTypePortlet;
058 import com.liferay.portal.model.Organization;
059 import com.liferay.portal.model.Portlet;
060 import com.liferay.portal.model.Resource;
061 import com.liferay.portal.model.ResourceConstants;
062 import com.liferay.portal.model.ResourcePermission;
063 import com.liferay.portal.model.Role;
064 import com.liferay.portal.model.RoleConstants;
065 import com.liferay.portal.model.User;
066 import com.liferay.portal.model.UserGroup;
067 import com.liferay.portal.model.UserPersonalSite;
068 import com.liferay.portal.model.impl.LayoutImpl;
069 import com.liferay.portal.security.permission.ActionKeys;
070 import com.liferay.portal.security.permission.PermissionCacheUtil;
071 import com.liferay.portal.security.permission.ResourceActionsUtil;
072 import com.liferay.portal.service.ServiceContext;
073 import com.liferay.portal.service.base.GroupLocalServiceBaseImpl;
074 import com.liferay.portal.theme.ThemeLoader;
075 import com.liferay.portal.theme.ThemeLoaderFactory;
076 import com.liferay.portal.util.PortalUtil;
077 import com.liferay.portal.util.PortletCategoryKeys;
078 import com.liferay.portal.util.PortletKeys;
079 import com.liferay.portal.util.PropsUtil;
080 import com.liferay.portal.util.PropsValues;
081 import com.liferay.portal.util.comparator.GroupNameComparator;
082 import com.liferay.portlet.blogs.model.BlogsEntry;
083 import com.liferay.portlet.journal.model.JournalArticle;
084 import com.liferay.util.UniqueList;
085
086 import java.io.File;
087
088 import java.util.ArrayList;
089 import java.util.Arrays;
090 import java.util.HashMap;
091 import java.util.LinkedHashMap;
092 import java.util.List;
093 import java.util.Map;
094
095
173 public class GroupLocalServiceImpl extends GroupLocalServiceBaseImpl {
174
175
178 public GroupLocalServiceImpl() {
179 initImportLARFile();
180 }
181
182
207 public Group addGroup(
208 long userId, String className, long classPK, long liveGroupId,
209 String name, String description, int type, String friendlyURL,
210 boolean site, boolean active, ServiceContext serviceContext)
211 throws PortalException, SystemException {
212
213
214
215 User user = userPersistence.findByPrimaryKey(userId);
216 className = GetterUtil.getString(className);
217 long classNameId = PortalUtil.getClassNameId(className);
218 String friendlyName = name;
219
220 long groupId = 0;
221
222 while (true) {
223 groupId = counterLocalService.increment();
224
225 User screenNameUser = userPersistence.fetchByC_SN(
226 user.getCompanyId(), String.valueOf(groupId));
227
228 if (screenNameUser == null) {
229 break;
230 }
231 }
232
233 boolean staging = isStaging(serviceContext);
234
235 long groupClassNameId = PortalUtil.getClassNameId(Group.class);
236
237 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
238 className = Group.class.getName();
239 classNameId = groupClassNameId;
240 classPK = groupId;
241 }
242 else if (className.equals(Organization.class.getName())) {
243 name = getOrgGroupName(classPK, name);
244 }
245 else if (!GroupConstants.USER_PERSONAL_SITE.equals(name)) {
246 name = String.valueOf(classPK);
247 }
248
249 if (className.equals(Organization.class.getName()) && staging) {
250 classPK = liveGroupId;
251 }
252
253 long parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
254
255 if (className.equals(Layout.class.getName())) {
256 Layout layout = layoutLocalService.getLayout(classPK);
257
258 parentGroupId = layout.getGroupId();
259 }
260
261 friendlyURL = getFriendlyURL(
262 user.getCompanyId(), groupId, classNameId, classPK, friendlyName,
263 friendlyURL);
264
265 if (staging) {
266 name = name.concat(" (Staging)");
267 friendlyURL = friendlyURL.concat("-staging");
268 }
269
270 if (className.equals(Group.class.getName())) {
271 if (!site && (liveGroupId == 0)) {
272 throw new IllegalArgumentException();
273 }
274 }
275 else if (!className.equals(Organization.class.getName()) &&
276 className.startsWith("com.liferay.portal.model.")) {
277
278 if (site) {
279 throw new IllegalArgumentException();
280 }
281 }
282
283 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
284 validateName(groupId, user.getCompanyId(), name);
285 }
286
287 validateFriendlyURL(
288 user.getCompanyId(), groupId, classNameId, classPK, friendlyURL);
289
290 Group group = groupPersistence.create(groupId);
291
292 group.setCompanyId(user.getCompanyId());
293 group.setCreatorUserId(userId);
294 group.setClassNameId(classNameId);
295 group.setClassPK(classPK);
296 group.setParentGroupId(parentGroupId);
297 group.setLiveGroupId(liveGroupId);
298 group.setName(name);
299 group.setDescription(description);
300 group.setType(type);
301 group.setFriendlyURL(friendlyURL);
302 group.setSite(site);
303 group.setActive(active);
304
305 groupPersistence.update(group, false);
306
307
308
309 layoutSetLocalService.addLayoutSet(groupId, true);
310
311 layoutSetLocalService.addLayoutSet(groupId, false);
312
313 if ((classNameId == groupClassNameId) && !user.isDefaultUser()) {
314
315
316
317 resourceLocalService.addResources(
318 group.getCompanyId(), 0, 0, Group.class.getName(),
319 group.getGroupId(), false, false, false);
320
321
322
323 Role role = roleLocalService.getRole(
324 group.getCompanyId(), RoleConstants.SITE_OWNER);
325
326 userGroupRoleLocalService.addUserGroupRoles(
327 userId, groupId, new long[] {role.getRoleId()});
328
329
330
331 userLocalService.addGroupUsers(
332 group.getGroupId(), new long[] {userId});
333
334
335
336 if (serviceContext != null) {
337 updateAsset(
338 userId, group, serviceContext.getAssetCategoryIds(),
339 serviceContext.getAssetTagNames());
340 }
341 }
342 else if (className.equals(Organization.class.getName()) &&
343 !user.isDefaultUser()) {
344
345
346
347 resourceLocalService.addResources(
348 group.getCompanyId(), 0, 0, Group.class.getName(),
349 group.getGroupId(), false, false, false);
350 }
351
352 return group;
353 }
354
355
378 public Group addGroup(
379 long userId, String className, long classPK, String name,
380 String description, int type, String friendlyURL, boolean site,
381 boolean active, ServiceContext serviceContext)
382 throws PortalException, SystemException {
383
384 return addGroup(
385 userId, className, classPK, GroupConstants.DEFAULT_LIVE_GROUP_ID,
386 name, description, type, friendlyURL, site, active, serviceContext);
387 }
388
389
396 public void addRoleGroups(long roleId, long[] groupIds)
397 throws SystemException {
398
399 rolePersistence.addGroups(roleId, groupIds);
400
401 PermissionCacheUtil.clearCache();
402 }
403
404
411 public void addUserGroups(long userId, long[] groupIds)
412 throws SystemException {
413
414 userPersistence.addGroups(userId, groupIds);
415
416 PermissionCacheUtil.clearCache();
417 }
418
419
430 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
431 public void checkCompanyGroup(long companyId)
432 throws PortalException, SystemException {
433
434 long classNameId = PortalUtil.getClassNameId(Company.class);
435
436 int count = groupPersistence.countByC_C_C(
437 companyId, classNameId, companyId);
438
439 if (count == 0) {
440 long defaultUserId = userLocalService.getDefaultUserId(companyId);
441
442 groupLocalService.addGroup(
443 defaultUserId, Company.class.getName(), companyId, null, null,
444 0, null, false, true, null);
445 }
446 }
447
448
457 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
458 public void checkSystemGroups(long companyId)
459 throws PortalException, SystemException {
460
461 String companyIdHexString = StringUtil.toHexString(companyId);
462
463 for (Group group : groupFinder.findBySystem(companyId)) {
464 _systemGroupsMap.put(
465 companyIdHexString.concat(group.getName()), group);
466 }
467
468 long defaultUserId = userLocalService.getDefaultUserId(companyId);
469
470 String[] systemGroups = PortalUtil.getSystemGroups();
471
472 for (String name : systemGroups) {
473 String groupCacheKey = companyIdHexString.concat(name);
474
475 Group group = _systemGroupsMap.get(groupCacheKey);
476
477 if (group == null) {
478 group = groupPersistence.fetchByC_N(companyId, name);
479 }
480
481 if (group == null) {
482 String className = null;
483 long classPK = 0;
484 int type = GroupConstants.TYPE_SITE_OPEN;
485 String friendlyURL = null;
486 boolean site = true;
487
488 if (name.equals(GroupConstants.CONTROL_PANEL)) {
489 type = GroupConstants.TYPE_SITE_PRIVATE;
490 friendlyURL = GroupConstants.CONTROL_PANEL_FRIENDLY_URL;
491 }
492 else if (name.equals(GroupConstants.GUEST)) {
493 friendlyURL = "/guest";
494 }
495 else if (name.equals(GroupConstants.USER_PERSONAL_SITE)) {
496 className = UserPersonalSite.class.getName();
497 classPK = defaultUserId;
498 type = GroupConstants.TYPE_SITE_PRIVATE;
499 friendlyURL =
500 GroupConstants.USER_PERSONAL_SITE_FRIENDLY_URL;
501 site = false;
502 }
503
504 group = groupLocalService.addGroup(
505 defaultUserId, className, classPK, name, null, type,
506 friendlyURL, site, true, null);
507
508 if (name.equals(GroupConstants.USER_PERSONAL_SITE)) {
509 initUserPersonalSitePermissions(group);
510 }
511 }
512
513 if (group.isControlPanel()) {
514 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
515 group.getGroupId(), true);
516
517 if (layoutSet.getPageCount() == 0) {
518 addControlPanelLayouts(group);
519 }
520 }
521
522 if (group.getName().equals(GroupConstants.GUEST)) {
523 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
524 group.getGroupId(), false);
525
526 if (layoutSet.getPageCount() == 0) {
527 addDefaultGuestPublicLayouts(group);
528 }
529 }
530
531 _systemGroupsMap.put(groupCacheKey, group);
532 }
533 }
534
535
551 @Override
552 public void deleteGroup(Group group)
553 throws PortalException, SystemException {
554
555 if (PortalUtil.isSystemGroup(group.getName())) {
556 throw new RequiredGroupException(
557 String.valueOf(group.getGroupId()));
558 }
559
560
561
562 layoutSetBranchLocalService.deleteLayoutSetBranches(
563 group.getGroupId(), true, true);
564
565 layoutSetBranchLocalService.deleteLayoutSetBranches(
566 group.getGroupId(), false, true);
567
568
569
570 ServiceContext serviceContext = new ServiceContext();
571
572 try {
573 layoutSetLocalService.deleteLayoutSet(
574 group.getGroupId(), true, serviceContext);
575 }
576 catch (NoSuchLayoutSetException nslse) {
577 }
578
579 try {
580 layoutSetLocalService.deleteLayoutSet(
581 group.getGroupId(), false, serviceContext);
582 }
583 catch (NoSuchLayoutSetException nslse) {
584 }
585
586
587
588 userGroupRoleLocalService.deleteUserGroupRolesByGroupId(
589 group.getGroupId());
590
591
592
593 userGroupGroupRoleLocalService.deleteUserGroupGroupRolesByGroupId(
594 group.getGroupId());
595
596
597
598 membershipRequestLocalService.deleteMembershipRequests(
599 group.getGroupId());
600
601
602
603 subscriptionLocalService.deleteSubscriptions(
604 group.getCompanyId(), BlogsEntry.class.getName(),
605 group.getGroupId());
606 subscriptionLocalService.deleteSubscriptions(
607 group.getCompanyId(), JournalArticle.class.getName(),
608 group.getGroupId());
609
610
611
612 teamLocalService.deleteTeams(group.getGroupId());
613
614
615
616 unscheduleStaging(group);
617
618 if (group.hasStagingGroup()) {
619 deleteGroup(group.getStagingGroup().getGroupId());
620 }
621
622
623
624 ThemeLoader themeLoader = ThemeLoaderFactory.getDefaultThemeLoader();
625
626 if (themeLoader != null) {
627 String themePath =
628 themeLoader.getFileStorage() + StringPool.SLASH +
629 group.getGroupId();
630
631 FileUtil.deltree(themePath + "-private");
632 FileUtil.deltree(themePath + "-public");
633 }
634
635
636
637 if (group.isRegularSite()) {
638 assetEntryLocalService.deleteEntry(
639 Group.class.getName(), group.getGroupId());
640 }
641
642 assetVocabularyLocalService.deleteVocabularies(group.getGroupId());
643
644
645
646 blogsEntryLocalService.deleteEntries(group.getGroupId());
647 blogsStatsUserLocalService.deleteStatsUserByGroupId(group.getGroupId());
648
649
650
651 bookmarksFolderLocalService.deleteFolders(group.getGroupId());
652
653
654
655 calEventLocalService.deleteEvents(group.getGroupId());
656
657
658
659 dlFileEntryTypeLocalService.deleteFileEntryTypes(group.getGroupId());
660 repositoryLocalService.deleteRepositories(group.getGroupId());
661
662
663
664 journalArticleLocalService.deleteArticles(group.getGroupId());
665 journalTemplateLocalService.deleteTemplates(group.getGroupId());
666 journalStructureLocalService.deleteStructures(group.getGroupId());
667
668
669
670 mbBanLocalService.deleteBansByGroupId(group.getGroupId());
671 mbCategoryLocalService.deleteCategories(group.getGroupId());
672 mbStatsUserLocalService.deleteStatsUsersByGroupId(group.getGroupId());
673
674
675
676 pollsQuestionLocalService.deleteQuestions(group.getGroupId());
677
678
679
680 shoppingCartLocalService.deleteGroupCarts(group.getGroupId());
681 shoppingCategoryLocalService.deleteCategories(group.getGroupId());
682 shoppingCouponLocalService.deleteCoupons(group.getGroupId());
683 shoppingOrderLocalService.deleteOrders(group.getGroupId());
684
685
686
687 scFrameworkVersionLocalService.deleteFrameworkVersions(
688 group.getGroupId());
689 scProductEntryLocalService.deleteProductEntries(group.getGroupId());
690
691
692
693 wikiNodeLocalService.deleteNodes(group.getGroupId());
694
695
696
697 if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
698 List<ResourcePermission> resourcePermissions =
699 resourcePermissionFinder.findByC_P(
700 group.getCompanyId(), String.valueOf(group.getGroupId()));
701
702 for (ResourcePermission resourcePermission : resourcePermissions) {
703 resourcePermissionLocalService.deleteResourcePermission(
704 resourcePermission);
705 }
706 }
707 else {
708 List<Resource> resources = resourceFinder.findByC_P(
709 group.getCompanyId(), String.valueOf(group.getGroupId()));
710
711 for (Resource resource : resources) {
712 resourceLocalService.deleteResource(resource);
713 }
714 }
715
716 if (!group.isStagingGroup() &&
717 (group.isOrganization()) || group.isRegularSite()) {
718
719 resourceLocalService.deleteResource(
720 group.getCompanyId(), Group.class.getName(),
721 ResourceConstants.SCOPE_INDIVIDUAL, group.getGroupId());
722 }
723
724
725
726 if (group.isOrganization() && group.isSite()) {
727 group.setSite(false);
728
729 groupPersistence.update(group, false);
730 }
731 else {
732 groupPersistence.remove(group);
733 }
734
735
736
737 PermissionCacheUtil.clearCache();
738 }
739
740
756 @Override
757 public void deleteGroup(long groupId)
758 throws PortalException, SystemException {
759
760 Group group = groupPersistence.findByPrimaryKey(groupId);
761
762 deleteGroup(group);
763 }
764
765
774 public Group fetchFriendlyURLGroup(long companyId, String friendlyURL)
775 throws SystemException {
776
777 if (Validator.isNull(friendlyURL)) {
778 return null;
779 }
780
781 friendlyURL = getFriendlyURL(friendlyURL);
782
783 return groupPersistence.fetchByC_F(companyId, friendlyURL);
784 }
785
786
795 @Skip
796 public Group fetchGroup(long companyId, String name)
797 throws SystemException {
798
799 Group group = _systemGroupsMap.get(
800 StringUtil.toHexString(companyId).concat(name));
801
802 if (group != null) {
803 return group;
804 }
805
806 return groupLocalService.loadFetchGroup(companyId, name);
807 }
808
809
817 public Group getCompanyGroup(long companyId)
818 throws PortalException, SystemException {
819
820 long classNameId = PortalUtil.getClassNameId(Company.class);
821
822 return groupPersistence.findByC_C_C(companyId, classNameId, companyId);
823 }
824
825
845 public List<Group> getCompanyGroups(long companyId, int start, int end)
846 throws SystemException {
847
848 return groupPersistence.findByCompanyId(companyId, start, end);
849 }
850
851
858 public int getCompanyGroupsCount(long companyId) throws SystemException {
859 return groupPersistence.countByCompanyId(companyId);
860 }
861
862
872 public Group getFriendlyURLGroup(long companyId, String friendlyURL)
873 throws PortalException, SystemException {
874
875 if (Validator.isNull(friendlyURL)) {
876 throw new NoSuchGroupException();
877 }
878
879 friendlyURL = getFriendlyURL(friendlyURL);
880
881 return groupPersistence.findByC_F(companyId, friendlyURL);
882 }
883
884
893 @Override
894 @ThreadLocalCachable
895 public Group getGroup(long groupId)
896 throws PortalException, SystemException {
897
898 return groupPersistence.findByPrimaryKey(groupId);
899 }
900
901
910 @Skip
911 public Group getGroup(long companyId, String name)
912 throws PortalException, SystemException {
913
914 Group group = _systemGroupsMap.get(
915 StringUtil.toHexString(companyId).concat(name));
916
917 if (group != null) {
918 return group;
919 }
920
921 return groupLocalService.loadGetGroup(companyId, name);
922 }
923
924
932 public List<Group> getGroups(long[] groupIds)
933 throws PortalException, SystemException {
934
935 List<Group> groups = new ArrayList<Group>(groupIds.length);
936
937 for (long groupId : groupIds) {
938 Group group = getGroup(groupId);
939
940 groups.add(group);
941 }
942
943 return groups;
944 }
945
946
955 public Group getLayoutGroup(long companyId, long plid)
956 throws PortalException, SystemException {
957
958 long classNameId = PortalUtil.getClassNameId(Layout.class);
959
960 return groupPersistence.findByC_C_C(companyId, classNameId, plid);
961 }
962
963
972 public Group getLayoutPrototypeGroup(long companyId, long layoutPrototypeId)
973 throws PortalException, SystemException {
974
975 long classNameId = PortalUtil.getClassNameId(LayoutPrototype.class);
976
977 return groupPersistence.findByC_C_C(
978 companyId, classNameId, layoutPrototypeId);
979 }
980
981
990 public Group getLayoutSetPrototypeGroup(
991 long companyId, long layoutSetPrototypeId)
992 throws PortalException, SystemException {
993
994 long classNameId = PortalUtil.getClassNameId(LayoutSetPrototype.class);
995
996 return groupPersistence.findByC_C_C(
997 companyId, classNameId, layoutSetPrototypeId);
998 }
999
1000
1006 public List<Group> getLiveGroups() throws SystemException {
1007 return groupFinder.findByLiveGroups();
1008 }
1009
1010
1033 public List<Group> getNoLayoutsGroups(
1034 String className, boolean privateLayout, int start, int end)
1035 throws SystemException {
1036
1037 long classNameId = PortalUtil.getClassNameId(className);
1038
1039 return groupFinder.findByNoLayouts(
1040 classNameId, privateLayout, start, end);
1041 }
1042
1043
1051 public List<Group> getNullFriendlyURLGroups() throws SystemException {
1052 return groupFinder.findByNullFriendlyURL();
1053 }
1054
1055
1064 public Group getOrganizationGroup(long companyId, long organizationId)
1065 throws PortalException, SystemException {
1066
1067 long classNameId = PortalUtil.getClassNameId(Organization.class);
1068
1069 return groupPersistence.findByC_C_C(
1070 companyId, classNameId, organizationId);
1071 }
1072
1073
1079 public List<Group> getOrganizationsGroups(
1080 List<Organization> organizations) {
1081
1082 List<Group> organizationGroups = new ArrayList<Group>();
1083
1084 for (int i = 0; i < organizations.size(); i++) {
1085 Organization organization = organizations.get(i);
1086
1087 Group group = organization.getGroup();
1088
1089 organizationGroups.add(group);
1090 }
1091
1092 return organizationGroups;
1093 }
1094
1095
1102 public List<Group> getOrganizationsRelatedGroups(
1103 List<Organization> organizations)
1104 throws SystemException {
1105
1106 List<Group> organizationGroups = new ArrayList<Group>();
1107
1108 for (int i = 0; i < organizations.size(); i++) {
1109 Organization organization = organizations.get(i);
1110
1111 List<Group> groups = organizationPersistence.getGroups(
1112 organization.getOrganizationId());
1113
1114 organizationGroups.addAll(groups);
1115 }
1116
1117 return organizationGroups;
1118 }
1119
1120
1127 public List<Group> getRoleGroups(long roleId) throws SystemException {
1128 return rolePersistence.getGroups(roleId);
1129 }
1130
1131
1139 public Group getStagingGroup(long liveGroupId)
1140 throws PortalException, SystemException {
1141
1142 return groupPersistence.findByLiveGroupId(liveGroupId);
1143 }
1144
1145
1154 public Group getUserGroup(long companyId, long userId)
1155 throws PortalException, SystemException {
1156
1157 long classNameId = PortalUtil.getClassNameId(User.class);
1158
1159 return groupPersistence.findByC_C_C(companyId, classNameId, userId);
1160 }
1161
1162
1172 public Group getUserGroupGroup(long companyId, long userGroupId)
1173 throws PortalException, SystemException {
1174
1175 long classNameId = PortalUtil.getClassNameId(UserGroup.class);
1176
1177 return groupPersistence.findByC_C_C(
1178 companyId, classNameId, userGroupId);
1179 }
1180
1181
1190 public List<Group> getUserGroups(long userId)
1191 throws PortalException, SystemException {
1192
1193 return getUserGroups(userId, false);
1194 }
1195
1196
1208 public List<Group> getUserGroups(long userId, boolean inherit)
1209 throws PortalException, SystemException {
1210
1211 return getUserGroups(
1212 userId, inherit, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1213 }
1214
1215
1242 public List<Group> getUserGroups(
1243 long userId, boolean inherit, int start, int end)
1244 throws PortalException, SystemException {
1245
1246 if (inherit) {
1247 User user = userPersistence.findByPrimaryKey(userId);
1248
1249 LinkedHashMap<String, Object> groupParams =
1250 new LinkedHashMap<String, Object>();
1251
1252 groupParams.put("usersGroups", new Long(userId));
1253
1254 return search(
1255 user.getCompanyId(), null, null, groupParams, start, end);
1256 }
1257 else {
1258 return userPersistence.getGroups(userId, start, end);
1259 }
1260 }
1261
1262
1285 public List<Group> getUserGroups(long userId, int start, int end)
1286 throws PortalException, SystemException {
1287
1288 return getUserGroups(userId, false, start, end);
1289 }
1290
1291
1300 public List<Group> getUserGroupsGroups(List<UserGroup> userGroups)
1301 throws PortalException, SystemException {
1302
1303 List<Group> userGroupGroups = new ArrayList<Group>();
1304
1305 for (int i = 0; i < userGroups.size(); i++) {
1306 UserGroup userGroup = userGroups.get(i);
1307
1308 Group group = userGroup.getGroup();
1309
1310 userGroupGroups.add(group);
1311 }
1312
1313 return userGroupGroups;
1314 }
1315
1316
1323 public List<Group> getUserGroupsRelatedGroups(List<UserGroup> userGroups)
1324 throws SystemException {
1325
1326 List<Group> userGroupGroups = new ArrayList<Group>();
1327
1328 for (int i = 0; i < userGroups.size(); i++) {
1329 UserGroup userGroup = userGroups.get(i);
1330
1331 List<Group> groups = userGroupPersistence.getGroups(
1332 userGroup.getUserGroupId());
1333
1334 userGroupGroups.addAll(groups);
1335 }
1336
1337 return userGroupGroups;
1338 }
1339
1340
1366 public List<Group> getUserOrganizationsGroups(
1367 long userId, int start, int end)
1368 throws PortalException, SystemException {
1369
1370 List<Group> userOrgsGroups = new UniqueList<Group>();
1371
1372 List<Organization> userOrgs =
1373 organizationLocalService.getUserOrganizations(userId, start, end);
1374
1375 for (Organization organization : userOrgs) {
1376 userOrgsGroups.add(0, organization.getGroup());
1377
1378 if (!PropsValues.ORGANIZATIONS_MEMBERSHIP_STRICT) {
1379 for (Organization ancestorOrganization :
1380 organization.getAncestors()) {
1381
1382 userOrgsGroups.add(0, ancestorOrganization.getGroup());
1383 }
1384 }
1385 }
1386
1387 return userOrgsGroups;
1388 }
1389
1390
1399 public boolean hasRoleGroup(long roleId, long groupId)
1400 throws SystemException {
1401
1402 return rolePersistence.containsGroup(roleId, groupId);
1403 }
1404
1405
1413 public boolean hasStagingGroup(long liveGroupId) throws SystemException {
1414 if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
1415 return true;
1416 }
1417 else {
1418 return false;
1419 }
1420 }
1421
1422
1433 public boolean hasUserGroup(long userId, long groupId)
1434 throws SystemException {
1435
1436 return hasUserGroup(userId, groupId, true);
1437 }
1438
1439
1452 public boolean hasUserGroup(long userId, long groupId, boolean inherit)
1453 throws SystemException {
1454
1455 if (groupFinder.countByG_U(groupId, userId, inherit) > 0) {
1456 return true;
1457 }
1458 else {
1459 return false;
1460 }
1461 }
1462
1463 public Group loadFetchGroup(long companyId, String name)
1464 throws SystemException {
1465
1466 return groupPersistence.fetchByC_N(companyId, name);
1467 }
1468
1469 public Group loadGetGroup(long companyId, String name)
1470 throws PortalException, SystemException {
1471
1472 return groupPersistence.findByC_N(companyId, name);
1473 }
1474
1475 public List<Group> search(
1476 long companyId, LinkedHashMap<String, Object> params, int start,
1477 int end)
1478 throws SystemException {
1479
1480 return groupFinder.findByCompanyId(
1481 companyId, params, start, end, new GroupNameComparator(true));
1482 }
1483
1484
1520 public List<Group> search(
1521 long companyId, long[] classNameIds, String name,
1522 String description, LinkedHashMap<String, Object> params, int start,
1523 int end)
1524 throws SystemException {
1525
1526 return search(
1527 companyId, classNameIds, name, description, params, start, end,
1528 null);
1529 }
1530
1531
1568 public List<Group> search(
1569 long companyId, long[] classNameIds, String name,
1570 String description, LinkedHashMap<String, Object> params, int start,
1571 int end, OrderByComparator obc)
1572 throws SystemException {
1573
1574 if (obc == null) {
1575 obc = new GroupNameComparator(true);
1576 }
1577
1578 String realName = getRealName(companyId, name);
1579
1580 return groupFinder.findByC_C_N_D(
1581 companyId, classNameIds, name, realName, description, params, start,
1582 end, obc);
1583 }
1584
1585
1617 public List<Group> search(
1618 long companyId, String name, String description,
1619 LinkedHashMap<String, Object> params, int start, int end)
1620 throws SystemException {
1621
1622 return search(companyId, name, description, params, start, end, null);
1623 }
1624
1625
1659 public List<Group> search(
1660 long companyId, String name, String description,
1661 LinkedHashMap<String, Object> params, int start, int end,
1662 OrderByComparator obc)
1663 throws SystemException {
1664
1665 if (obc == null) {
1666 obc = new GroupNameComparator(true);
1667 }
1668
1669 String realName = getRealName(companyId, name);
1670
1671 return groupFinder.findByC_N_D(
1672 companyId, name, realName, description, params, start, end, obc);
1673 }
1674
1675
1695 @ThreadLocalCachable
1696 public int searchCount(
1697 long companyId, long[] classNameIds, String name,
1698 String description, LinkedHashMap<String, Object> params)
1699 throws SystemException {
1700
1701 String realName = getRealName(companyId, name);
1702
1703 return groupFinder.countByC_C_N_D(
1704 companyId, classNameIds, name, realName, description, params);
1705 }
1706
1707
1726 @ThreadLocalCachable
1727 public int searchCount(
1728 long companyId, String name, String description,
1729 LinkedHashMap<String, Object> params)
1730 throws SystemException {
1731
1732 String realName = getRealName(companyId, name);
1733
1734 return groupFinder.countByC_N_D(
1735 companyId, name, realName, description, params);
1736 }
1737
1738
1746 public void setRoleGroups(long roleId, long[] groupIds)
1747 throws SystemException {
1748
1749 rolePersistence.setGroups(roleId, groupIds);
1750
1751 PermissionCacheUtil.clearCache();
1752 }
1753
1754
1761 public void unsetRoleGroups(long roleId, long[] groupIds)
1762 throws SystemException {
1763
1764 rolePersistence.removeGroups(roleId, groupIds);
1765
1766 PermissionCacheUtil.clearCache();
1767 }
1768
1769
1776 public void unsetUserGroups(long userId, long[] groupIds)
1777 throws SystemException {
1778
1779 userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
1780
1781 userPersistence.removeGroups(userId, groupIds);
1782
1783 PermissionCacheUtil.clearCache();
1784 }
1785
1786
1797 public void updateAsset(
1798 long userId, Group group, long[] assetCategoryIds,
1799 String[] assetTagNames)
1800 throws PortalException, SystemException {
1801
1802 User user = userPersistence.findByPrimaryKey(userId);
1803
1804 Company company = companyPersistence.findByPrimaryKey(
1805 user.getCompanyId());
1806
1807 Group companyGroup = company.getGroup();
1808
1809 assetEntryLocalService.updateEntry(
1810 userId, companyGroup.getGroupId(), Group.class.getName(),
1811 group.getGroupId(), null, 0, assetCategoryIds, assetTagNames, false,
1812 null, null, null, null, null, group.getDescriptiveName(),
1813 group.getDescription(), null, null, null, 0, 0, null, false);
1814 }
1815
1816
1828 public Group updateFriendlyURL(long groupId, String friendlyURL)
1829 throws PortalException, SystemException {
1830
1831 Group group = groupPersistence.findByPrimaryKey(groupId);
1832
1833 if (group.isUser()) {
1834 User user = userPersistence.findByPrimaryKey(group.getClassPK());
1835
1836 friendlyURL = StringPool.SLASH + user.getScreenName();
1837
1838 if (group.getFriendlyURL().equals(friendlyURL)) {
1839 return group;
1840 }
1841 }
1842
1843 friendlyURL = getFriendlyURL(
1844 group.getCompanyId(), groupId, group.getClassNameId(),
1845 group.getClassPK(), StringPool.BLANK, friendlyURL);
1846
1847 validateFriendlyURL(
1848 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
1849 group.getClassPK(), friendlyURL);
1850
1851 group.setFriendlyURL(friendlyURL);
1852
1853 groupPersistence.update(group, false);
1854
1855 return group;
1856 }
1857
1858
1869 public Group updateGroup(long groupId, String typeSettings)
1870 throws PortalException, SystemException {
1871
1872 Group group = groupPersistence.findByPrimaryKey(groupId);
1873
1874 group.setTypeSettings(typeSettings);
1875
1876 groupPersistence.update(group, false);
1877
1878 return group;
1879 }
1880
1881
1902 public Group updateGroup(
1903 long groupId, String name, String description, int type,
1904 String friendlyURL, boolean active, ServiceContext serviceContext)
1905 throws PortalException, SystemException {
1906
1907 Group group = groupPersistence.findByPrimaryKey(groupId);
1908
1909 String className = group.getClassName();
1910 long classNameId = group.getClassNameId();
1911 long classPK = group.getClassPK();
1912 friendlyURL = getFriendlyURL(
1913 group.getCompanyId(), groupId, classNameId, classPK,
1914 StringPool.BLANK, friendlyURL);
1915
1916 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
1917 validateName(group.getGroupId(), group.getCompanyId(), name);
1918 }
1919 else {
1920 name = String.valueOf(classPK);
1921 }
1922
1923 if (PortalUtil.isSystemGroup(group.getName()) &&
1924 !group.getName().equals(name)) {
1925
1926 throw new RequiredGroupException();
1927 }
1928
1929 validateFriendlyURL(
1930 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
1931 group.getClassPK(), friendlyURL);
1932
1933 group.setName(name);
1934 group.setDescription(description);
1935 group.setType(type);
1936 group.setFriendlyURL(friendlyURL);
1937 group.setActive(active);
1938
1939 groupPersistence.update(group, false);
1940
1941
1942
1943 if ((serviceContext != null) && group.isSite()) {
1944 User user = null;
1945
1946 try {
1947 user = userPersistence.findByPrimaryKey(
1948 group.getCreatorUserId());
1949
1950 }
1951 catch (NoSuchUserException nsue1) {
1952 try {
1953 user = userPersistence.findByPrimaryKey(
1954 serviceContext.getUserId());
1955 }
1956 catch (NoSuchUserException nsue2) {
1957 user = userLocalService.getDefaultUser(
1958 group.getCompanyId());
1959 }
1960 }
1961
1962 updateAsset(
1963 user.getUserId(), group, serviceContext.getAssetCategoryIds(),
1964 serviceContext.getAssetTagNames());
1965 }
1966
1967 return group;
1968 }
1969
1970
1980 public Group updateSite(long groupId, boolean site)
1981 throws PortalException, SystemException {
1982
1983 Group group = groupPersistence.findByPrimaryKey(groupId);
1984
1985 if (!group.isOrganization()) {
1986 return group;
1987 }
1988
1989 group.setSite(site);
1990
1991 groupPersistence.update(group, false);
1992
1993 return group;
1994 }
1995
1996 protected void addControlPanelLayouts(Group group)
1997 throws PortalException, SystemException {
1998
1999 long defaultUserId = userLocalService.getDefaultUserId(
2000 group.getCompanyId());
2001
2002 String friendlyURL = getFriendlyURL(
2003 PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
2004
2005 ServiceContext serviceContext = new ServiceContext();
2006
2007 layoutLocalService.addLayout(
2008 defaultUserId, group.getGroupId(), true,
2009 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
2010 PropsValues.CONTROL_PANEL_LAYOUT_NAME, StringPool.BLANK,
2011 StringPool.BLANK, LayoutConstants.TYPE_CONTROL_PANEL, false,
2012 friendlyURL, serviceContext);
2013 }
2014
2015 protected void addDefaultGuestPublicLayoutByProperties(Group group)
2016 throws PortalException, SystemException {
2017
2018 long defaultUserId = userLocalService.getDefaultUserId(
2019 group.getCompanyId());
2020 String friendlyURL = getFriendlyURL(
2021 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
2022
2023 ServiceContext serviceContext = new ServiceContext();
2024
2025 Layout layout = layoutLocalService.addLayout(
2026 defaultUserId, group.getGroupId(), false,
2027 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
2028 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
2029 StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL,
2030 serviceContext);
2031
2032 LayoutTypePortlet layoutTypePortlet =
2033 (LayoutTypePortlet)layout.getLayoutType();
2034
2035 layoutTypePortlet.setLayoutTemplateId(
2036 0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
2037
2038 for (int i = 0; i < 10; i++) {
2039 String columnId = "column-" + i;
2040 String portletIds = PropsUtil.get(
2041 PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_COLUMN + i);
2042
2043 layoutTypePortlet.addPortletIds(
2044 0, StringUtil.split(portletIds), columnId, false);
2045 }
2046
2047 layoutLocalService.updateLayout(
2048 layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
2049 layout.getTypeSettings());
2050
2051 boolean updateLayoutSet = false;
2052
2053 LayoutSet layoutSet = layout.getLayoutSet();
2054
2055 if (Validator.isNotNull(
2056 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
2057
2058 layoutSet.setThemeId(
2059 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
2060
2061 updateLayoutSet = true;
2062 }
2063
2064 if (Validator.isNotNull(
2065 PropsValues.
2066 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
2067
2068 layoutSet.setColorSchemeId(
2069 PropsValues.
2070 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
2071
2072 updateLayoutSet = true;
2073 }
2074
2075 if (Validator.isNotNull(
2076 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
2077
2078 layoutSet.setWapThemeId(
2079 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
2080
2081 updateLayoutSet = true;
2082 }
2083
2084 if (Validator.isNotNull(
2085 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
2086
2087 layoutSet.setWapColorSchemeId(
2088 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
2089
2090 updateLayoutSet = true;
2091 }
2092
2093 if (updateLayoutSet) {
2094 layoutSetLocalService.updateLayoutSet(layoutSet);
2095 }
2096 }
2097
2098 protected void addDefaultGuestPublicLayouts(Group group)
2099 throws PortalException, SystemException {
2100
2101 if (publicLARFile != null) {
2102 addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
2103 }
2104 else {
2105 addDefaultGuestPublicLayoutByProperties(group);
2106 }
2107 }
2108
2109 protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
2110 throws PortalException, SystemException {
2111
2112 long defaultUserId = userLocalService.getDefaultUserId(
2113 group.getCompanyId());
2114
2115 Map<String, String[]> parameterMap = new HashMap<String, String[]>();
2116
2117 parameterMap.put(
2118 PortletDataHandlerKeys.CATEGORIES,
2119 new String[] {Boolean.TRUE.toString()});
2120 parameterMap.put(
2121 PortletDataHandlerKeys.PERMISSIONS,
2122 new String[] {Boolean.TRUE.toString()});
2123 parameterMap.put(
2124 PortletDataHandlerKeys.PORTLET_DATA,
2125 new String[] {Boolean.TRUE.toString()});
2126 parameterMap.put(
2127 PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
2128 new String[] {Boolean.TRUE.toString()});
2129 parameterMap.put(
2130 PortletDataHandlerKeys.PORTLET_SETUP,
2131 new String[] {Boolean.TRUE.toString()});
2132 parameterMap.put(
2133 PortletDataHandlerKeys.USER_PERMISSIONS,
2134 new String[] {Boolean.FALSE.toString()});
2135
2136 layoutLocalService.importLayouts(
2137 defaultUserId, group.getGroupId(), false, parameterMap, larFile);
2138 }
2139
2140 protected String getFriendlyURL(
2141 long companyId, long groupId, long classNameId, long classPK,
2142 String friendlyName, String friendlyURL)
2143 throws PortalException, SystemException {
2144
2145 friendlyURL = getFriendlyURL(friendlyURL);
2146
2147 if (Validator.isNotNull(friendlyURL)) {
2148 return friendlyURL;
2149 }
2150
2151 friendlyURL = StringPool.SLASH + getFriendlyURL(friendlyName);
2152
2153 String originalFriendlyURL = friendlyURL;
2154
2155 for (int i = 1;; i++) {
2156 try {
2157 validateFriendlyURL(
2158 companyId, groupId, classNameId, classPK, friendlyURL);
2159
2160 break;
2161 }
2162 catch (GroupFriendlyURLException gfurle) {
2163 int type = gfurle.getType();
2164
2165 if (type == GroupFriendlyURLException.DUPLICATE) {
2166 friendlyURL = originalFriendlyURL + i;
2167 }
2168 else {
2169 friendlyURL = StringPool.SLASH + classPK;
2170
2171 break;
2172 }
2173 }
2174 }
2175
2176 return friendlyURL;
2177 }
2178
2179 protected String getFriendlyURL(String friendlyURL) {
2180 return FriendlyURLNormalizerUtil.normalize(friendlyURL);
2181 }
2182
2183 protected String getOrgGroupName(long classPK, String name) {
2184 return classPK + _ORGANIZATION_NAME_DELIMETER + name;
2185 }
2186
2187 protected String getRealName(long companyId, String name)
2188 throws SystemException {
2189
2190 if (Validator.isNull(name)) {
2191 return name;
2192 }
2193
2194 String realName = name;
2195
2196 try {
2197 Company company = companyLocalService.getCompany(companyId);
2198
2199 Account account = company.getAccount();
2200
2201 String companyName = account.getName();
2202
2203 name = StringUtil.replace(
2204 name, StringPool.PERCENT, StringPool.BLANK);
2205
2206 if (companyName.indexOf(name) != -1) {
2207 realName = StringPool.PERCENT + GroupConstants.GUEST +
2208 StringPool.PERCENT;
2209 }
2210 }
2211 catch (PortalException pe) {
2212 }
2213
2214 return realName;
2215 }
2216
2217 protected void initImportLARFile() {
2218 String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
2219
2220 if (_log.isDebugEnabled()) {
2221 _log.debug("Reading public LAR file " + publicLARFileName);
2222 }
2223
2224 if (Validator.isNotNull(publicLARFileName)) {
2225 publicLARFile = new File(publicLARFileName);
2226
2227 if (!publicLARFile.exists()) {
2228 _log.error(
2229 "Public LAR file " + publicLARFile + " does not exist");
2230
2231 publicLARFile = null;
2232 }
2233 else {
2234 if (_log.isDebugEnabled()) {
2235 _log.debug("Using public LAR file " + publicLARFileName);
2236 }
2237 }
2238 }
2239 }
2240
2241 protected void initUserPersonalSitePermissions(Group group)
2242 throws PortalException, SystemException {
2243
2244
2245
2246 Role role = roleLocalService.getRole(
2247 group.getCompanyId(), RoleConstants.USER);
2248
2249 setCompanyPermissions(
2250 role, PortletKeys.PORTAL,
2251 new String[] {ActionKeys.VIEW_CONTROL_PANEL});
2252
2253 List<Portlet> portlets = portletLocalService.getPortlets(
2254 group.getCompanyId(), false, false);
2255
2256 for (Portlet portlet : portlets) {
2257 setRolePermissions(
2258 group, role, portlet.getPortletId(),
2259 new String[] {ActionKeys.VIEW});
2260 }
2261
2262 setRolePermissions(
2263 group, role, Layout.class.getName(),
2264 new String[] {ActionKeys.VIEW});
2265
2266 setRolePermissions(
2267 group, role, "com.liferay.portlet.blogs",
2268 new String[] {
2269 ActionKeys.ADD_ENTRY, ActionKeys.PERMISSIONS,
2270 ActionKeys.SUBSCRIBE});
2271
2272 setRolePermissions(
2273 group, role, "com.liferay.portlet.calendar",
2274 new String[] {
2275 ActionKeys.ADD_EVENT, ActionKeys.EXPORT_ALL_EVENTS,
2276 ActionKeys.PERMISSIONS});
2277
2278
2279
2280 role = roleLocalService.getRole(
2281 group.getCompanyId(), RoleConstants.POWER_USER);
2282
2283 for (Portlet portlet : portlets) {
2284 List<String> actions =
2285 ResourceActionsUtil.getPortletResourceActions(
2286 portlet.getPortletId());
2287
2288 String controlPanelEntryCategory = GetterUtil.getString(
2289 portlet.getControlPanelEntryCategory());
2290
2291 if (actions.contains(ActionKeys.ACCESS_IN_CONTROL_PANEL) &&
2292 controlPanelEntryCategory.equals(PortletCategoryKeys.CONTENT)) {
2293
2294 setRolePermissions(
2295 group, role, portlet.getPortletId(),
2296 new String[] {ActionKeys.ACCESS_IN_CONTROL_PANEL});
2297 }
2298 }
2299
2300 setRolePermissions(
2301 group, role, Group.class.getName(),
2302 new String[] {ActionKeys.MANAGE_LAYOUTS});
2303
2304 setRolePermissions(group, role, "com.liferay.portlet.asset");
2305 setRolePermissions(group, role, "com.liferay.portlet.blogs");
2306 setRolePermissions(group, role, "com.liferay.portlet.bookmarks");
2307 setRolePermissions(group, role, "com.liferay.portlet.calendar");
2308 setRolePermissions(group, role, "com.liferay.portlet.documentlibrary");
2309 setRolePermissions(group, role, "com.liferay.portlet.imagegallery");
2310 setRolePermissions(group, role, "com.liferay.portlet.messageboards");
2311 setRolePermissions(group, role, "com.liferay.portlet.polls");
2312 setRolePermissions(group, role, "com.liferay.portlet.wiki");
2313 }
2314
2315 protected boolean isStaging(ServiceContext serviceContext) {
2316 if (serviceContext != null) {
2317 return ParamUtil.getBoolean(serviceContext, "staging");
2318 }
2319
2320 return false;
2321 }
2322
2323 protected void setCompanyPermissions(
2324 Role role, String name, String[] actionIds)
2325 throws PortalException, SystemException {
2326
2327 if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
2328 if (resourceBlockLocalService.isSupported(name)) {
2329 resourceBlockLocalService.setCompanyScopePermissions(
2330 role.getCompanyId(), name, role.getRoleId(),
2331 Arrays.asList(actionIds));
2332 }
2333 else {
2334 resourcePermissionLocalService.setResourcePermissions(
2335 role.getCompanyId(), name, ResourceConstants.SCOPE_COMPANY,
2336 String.valueOf(role.getCompanyId()), role.getRoleId(),
2337 actionIds);
2338 }
2339 }
2340 else {
2341 permissionLocalService.setRolePermissions(
2342 role.getRoleId(), role.getCompanyId(), name,
2343 ResourceConstants.SCOPE_COMPANY,
2344 String.valueOf(role.getCompanyId()), actionIds);
2345 }
2346 }
2347
2348 protected void setRolePermissions(Group group, Role role, String name)
2349 throws PortalException, SystemException {
2350
2351 List<String> actions = ResourceActionsUtil.getModelResourceActions(
2352 name);
2353
2354 setRolePermissions(
2355 group, role, name, actions.toArray(new String[actions.size()]));
2356 }
2357
2358 protected void setRolePermissions(
2359 Group group, Role role, String name, String[] actionIds)
2360 throws PortalException, SystemException {
2361
2362 if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
2363 if (resourceBlockLocalService.isSupported(name)) {
2364 resourceBlockLocalService.setGroupScopePermissions(
2365 role.getCompanyId(), group.getGroupId(), name,
2366 role.getRoleId(), Arrays.asList(actionIds));
2367 }
2368 else {
2369 resourcePermissionLocalService.setResourcePermissions(
2370 group.getCompanyId(), name, ResourceConstants.SCOPE_GROUP,
2371 String.valueOf(group.getGroupId()), role.getRoleId(),
2372 actionIds);
2373 }
2374 }
2375 else {
2376 permissionLocalService.setRolePermissions(
2377 role.getRoleId(), group.getCompanyId(), name,
2378 ResourceConstants.SCOPE_GROUP,
2379 String.valueOf(group.getGroupId()), actionIds);
2380 }
2381 }
2382
2383 protected void unscheduleStaging(Group group) {
2384 try {
2385
2386
2387
2388 String groupName = StagingUtil.getSchedulerGroupName(
2389 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
2390
2391 SchedulerEngineUtil.delete(groupName, StorageType.PERSISTED);
2392
2393 long liveGroupId = 0;
2394 long stagingGroupId = 0;
2395
2396 if (group.isStagingGroup()) {
2397 liveGroupId = group.getLiveGroupId();
2398
2399 stagingGroupId = group.getGroupId();
2400 }
2401 else if (group.hasStagingGroup()) {
2402 liveGroupId = group.getGroupId();
2403
2404 stagingGroupId = group.getStagingGroup().getGroupId();
2405 }
2406
2407 if ((liveGroupId != 0) && (stagingGroupId != 0)) {
2408
2409
2410
2411 groupName = StagingUtil.getSchedulerGroupName(
2412 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
2413
2414 SchedulerEngineUtil.delete(groupName, StorageType.PERSISTED);
2415
2416
2417
2418 groupName = StagingUtil.getSchedulerGroupName(
2419 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
2420
2421 SchedulerEngineUtil.delete(groupName, StorageType.PERSISTED);
2422 }
2423 }
2424 catch (Exception e) {
2425 _log.error(
2426 "Unable to unschedule events for group: " + group.getGroupId());
2427 }
2428 }
2429
2430 protected void validateFriendlyURL(
2431 long companyId, long groupId, long classNameId, long classPK,
2432 String friendlyURL)
2433 throws PortalException, SystemException {
2434
2435 Company company = companyPersistence.findByPrimaryKey(companyId);
2436
2437 if (company.isSystem()) {
2438 return;
2439 }
2440
2441 if (Validator.isNull(friendlyURL)) {
2442 return;
2443 }
2444
2445 int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
2446
2447 if (exceptionType != -1) {
2448 throw new GroupFriendlyURLException(exceptionType);
2449 }
2450
2451 Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
2452
2453 if ((group != null) && (group.getGroupId() != groupId)) {
2454 throw new GroupFriendlyURLException(
2455 GroupFriendlyURLException.DUPLICATE);
2456 }
2457
2458 String groupIdFriendlyURL = friendlyURL.substring(1);
2459
2460 if (Validator.isNumber(groupIdFriendlyURL)) {
2461 long groupClassNameId = PortalUtil.getClassNameId(Group.class);
2462
2463 if (((classNameId != groupClassNameId) &&
2464 (!groupIdFriendlyURL.equals(String.valueOf(classPK))) &&
2465 (!PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC)) ||
2466 ((classNameId == groupClassNameId) &&
2467 (!groupIdFriendlyURL.equals(String.valueOf(groupId))))) {
2468
2469 GroupFriendlyURLException gfurle =
2470 new GroupFriendlyURLException(
2471 GroupFriendlyURLException.POSSIBLE_DUPLICATE);
2472
2473 gfurle.setKeywordConflict(groupIdFriendlyURL);
2474
2475 throw gfurle;
2476 }
2477 }
2478
2479 String screenName = friendlyURL.substring(1);
2480
2481 User user = userPersistence.fetchByC_SN(companyId, screenName);
2482
2483 if (user != null) {
2484 long userClassNameId = PortalUtil.getClassNameId(User.class);
2485
2486 if ((classNameId == userClassNameId) &&
2487 (classPK == user.getUserId())) {
2488 }
2489 else {
2490 throw new GroupFriendlyURLException(
2491 GroupFriendlyURLException.DUPLICATE);
2492 }
2493 }
2494
2495 if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
2496 throw new GroupFriendlyURLException(
2497 GroupFriendlyURLException.TOO_DEEP);
2498 }
2499 }
2500
2501 protected void validateName(long groupId, long companyId, String name)
2502 throws PortalException, SystemException {
2503
2504 if ((Validator.isNull(name)) || (Validator.isNumber(name)) ||
2505 (name.indexOf(CharPool.STAR) != -1) ||
2506 (name.indexOf(_ORGANIZATION_NAME_DELIMETER) != -1)) {
2507
2508 throw new GroupNameException();
2509 }
2510
2511 try {
2512 Group group = groupFinder.findByC_N(companyId, name);
2513
2514 if ((groupId <= 0) || (group.getGroupId() != groupId)) {
2515 throw new DuplicateGroupException();
2516 }
2517 }
2518 catch (NoSuchGroupException nsge) {
2519 }
2520 }
2521
2522 protected File publicLARFile;
2523
2524 private static final String _ORGANIZATION_NAME_DELIMETER =
2525 " LFR_ORGANIZATION ";
2526
2527 private static Log _log = LogFactoryUtil.getLog(
2528 GroupLocalServiceImpl.class);
2529
2530 private Map<String, Group> _systemGroupsMap = new HashMap<String, Group>();
2531
2532 }