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.language.LanguageUtil;
029 import com.liferay.portal.kernel.lar.PortletDataContext;
030 import com.liferay.portal.kernel.lar.PortletDataHandler;
031 import com.liferay.portal.kernel.lar.PortletDataHandlerKeys;
032 import com.liferay.portal.kernel.log.Log;
033 import com.liferay.portal.kernel.log.LogFactoryUtil;
034 import com.liferay.portal.kernel.messaging.DestinationNames;
035 import com.liferay.portal.kernel.scheduler.SchedulerEngineHelperUtil;
036 import com.liferay.portal.kernel.scheduler.StorageType;
037 import com.liferay.portal.kernel.spring.aop.Skip;
038 import com.liferay.portal.kernel.staging.StagingUtil;
039 import com.liferay.portal.kernel.transaction.Propagation;
040 import com.liferay.portal.kernel.transaction.Transactional;
041 import com.liferay.portal.kernel.util.FileUtil;
042 import com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil;
043 import com.liferay.portal.kernel.util.GetterUtil;
044 import com.liferay.portal.kernel.util.OrderByComparator;
045 import com.liferay.portal.kernel.util.ParamUtil;
046 import com.liferay.portal.kernel.util.PropsKeys;
047 import com.liferay.portal.kernel.util.StringPool;
048 import com.liferay.portal.kernel.util.StringUtil;
049 import com.liferay.portal.kernel.util.UniqueList;
050 import com.liferay.portal.kernel.util.Validator;
051 import com.liferay.portal.lar.PortletDataContextImpl;
052 import com.liferay.portal.model.Account;
053 import com.liferay.portal.model.Company;
054 import com.liferay.portal.model.Group;
055 import com.liferay.portal.model.GroupConstants;
056 import com.liferay.portal.model.Layout;
057 import com.liferay.portal.model.LayoutConstants;
058 import com.liferay.portal.model.LayoutPrototype;
059 import com.liferay.portal.model.LayoutSet;
060 import com.liferay.portal.model.LayoutSetPrototype;
061 import com.liferay.portal.model.LayoutTypePortlet;
062 import com.liferay.portal.model.Organization;
063 import com.liferay.portal.model.Portlet;
064 import com.liferay.portal.model.Resource;
065 import com.liferay.portal.model.ResourceConstants;
066 import com.liferay.portal.model.ResourcePermission;
067 import com.liferay.portal.model.Role;
068 import com.liferay.portal.model.RoleConstants;
069 import com.liferay.portal.model.User;
070 import com.liferay.portal.model.UserGroup;
071 import com.liferay.portal.model.UserPersonalSite;
072 import com.liferay.portal.model.impl.LayoutImpl;
073 import com.liferay.portal.security.permission.ActionKeys;
074 import com.liferay.portal.security.permission.PermissionCacheUtil;
075 import com.liferay.portal.security.permission.ResourceActionsUtil;
076 import com.liferay.portal.service.ServiceContext;
077 import com.liferay.portal.service.base.GroupLocalServiceBaseImpl;
078 import com.liferay.portal.theme.ThemeLoader;
079 import com.liferay.portal.theme.ThemeLoaderFactory;
080 import com.liferay.portal.util.PortalUtil;
081 import com.liferay.portal.util.PortletCategoryKeys;
082 import com.liferay.portal.util.PortletKeys;
083 import com.liferay.portal.util.PropsUtil;
084 import com.liferay.portal.util.PropsValues;
085 import com.liferay.portal.util.comparator.GroupNameComparator;
086 import com.liferay.portlet.blogs.model.BlogsEntry;
087 import com.liferay.portlet.journal.model.JournalArticle;
088
089 import java.io.File;
090
091 import java.util.ArrayList;
092 import java.util.Arrays;
093 import java.util.HashMap;
094 import java.util.HashSet;
095 import java.util.LinkedHashMap;
096 import java.util.List;
097 import java.util.Locale;
098 import java.util.Map;
099
100
178 public class GroupLocalServiceImpl extends GroupLocalServiceBaseImpl {
179
180 public static final String ORGANIZATION_NAME_SUFFIX = " LFR_ORGANIZATION";
181
182
185 public GroupLocalServiceImpl() {
186 initImportLARFile();
187 }
188
189
214 @Override
215 public Group addGroup(
216 long userId, String className, long classPK, long liveGroupId,
217 String name, String description, int type, String friendlyURL,
218 boolean site, boolean active, ServiceContext serviceContext)
219 throws PortalException, SystemException {
220
221
222
223 User user = userPersistence.findByPrimaryKey(userId);
224 className = GetterUtil.getString(className);
225 long classNameId = PortalUtil.getClassNameId(className);
226 String friendlyName = name;
227
228 long groupId = 0;
229
230 while (true) {
231 groupId = counterLocalService.increment();
232
233 User screenNameUser = userPersistence.fetchByC_SN(
234 user.getCompanyId(), String.valueOf(groupId));
235
236 if (screenNameUser == null) {
237 break;
238 }
239 }
240
241 boolean staging = isStaging(serviceContext);
242
243 long groupClassNameId = PortalUtil.getClassNameId(Group.class);
244
245 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
246 className = Group.class.getName();
247 classNameId = groupClassNameId;
248 classPK = groupId;
249 }
250 else if (className.equals(Organization.class.getName())) {
251 name = getOrgGroupName(name);
252 }
253 else if (!GroupConstants.USER_PERSONAL_SITE.equals(name)) {
254 name = String.valueOf(classPK);
255 }
256
257 if (className.equals(Organization.class.getName()) && staging) {
258 classPK = liveGroupId;
259 }
260
261 long parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
262
263 if (className.equals(Layout.class.getName())) {
264 Layout layout = layoutLocalService.getLayout(classPK);
265
266 parentGroupId = layout.getGroupId();
267 }
268
269 friendlyURL = getFriendlyURL(
270 user.getCompanyId(), groupId, classNameId, classPK, friendlyName,
271 friendlyURL);
272
273 if (staging) {
274 name = name.concat(" (Staging)");
275 friendlyURL = friendlyURL.concat("-staging");
276 }
277
278 if (className.equals(Group.class.getName())) {
279 if (!site && (liveGroupId == 0) &&
280 !name.equals(GroupConstants.CONTROL_PANEL)) {
281
282 throw new IllegalArgumentException();
283 }
284 }
285 else if (!className.equals(Organization.class.getName()) &&
286 className.startsWith("com.liferay.portal.model.")) {
287
288 if (site) {
289 throw new IllegalArgumentException();
290 }
291 }
292
293 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
294 validateName(groupId, user.getCompanyId(), name, site);
295 }
296
297 validateFriendlyURL(
298 user.getCompanyId(), groupId, classNameId, classPK, friendlyURL);
299
300 Group group = groupPersistence.create(groupId);
301
302 group.setCompanyId(user.getCompanyId());
303 group.setCreatorUserId(userId);
304 group.setClassNameId(classNameId);
305 group.setClassPK(classPK);
306 group.setParentGroupId(parentGroupId);
307 group.setLiveGroupId(liveGroupId);
308 group.setName(name);
309 group.setDescription(description);
310 group.setType(type);
311 group.setFriendlyURL(friendlyURL);
312 group.setSite(site);
313 group.setActive(active);
314
315 if ((serviceContext != null) && (classNameId == groupClassNameId) &&
316 !user.isDefaultUser()) {
317
318 group.setExpandoBridgeAttributes(serviceContext);
319 }
320
321 groupPersistence.update(group, false);
322
323
324
325 layoutSetLocalService.addLayoutSet(groupId, true);
326
327 layoutSetLocalService.addLayoutSet(groupId, false);
328
329 if ((classNameId == groupClassNameId) && !user.isDefaultUser()) {
330
331
332
333 resourceLocalService.addResources(
334 group.getCompanyId(), 0, 0, Group.class.getName(),
335 group.getGroupId(), false, false, false);
336
337
338
339 Role role = roleLocalService.getRole(
340 group.getCompanyId(), RoleConstants.SITE_OWNER);
341
342 userGroupRoleLocalService.addUserGroupRoles(
343 userId, groupId, new long[] {role.getRoleId()});
344
345
346
347 userLocalService.addGroupUsers(
348 group.getGroupId(), new long[] {userId});
349
350
351
352 if (serviceContext != null) {
353 updateAsset(
354 userId, group, serviceContext.getAssetCategoryIds(),
355 serviceContext.getAssetTagNames());
356 }
357 }
358 else if (className.equals(Organization.class.getName()) &&
359 !user.isDefaultUser()) {
360
361
362
363 resourceLocalService.addResources(
364 group.getCompanyId(), 0, 0, Group.class.getName(),
365 group.getGroupId(), false, false, false);
366 }
367
368 return group;
369 }
370
371
394 @Override
395 public Group addGroup(
396 long userId, String className, long classPK, String name,
397 String description, int type, String friendlyURL, boolean site,
398 boolean active, ServiceContext serviceContext)
399 throws PortalException, SystemException {
400
401 return addGroup(
402 userId, className, classPK, GroupConstants.DEFAULT_LIVE_GROUP_ID,
403 name, description, type, friendlyURL, site, active, serviceContext);
404 }
405
406
413 @Override
414 public void addRoleGroups(long roleId, long[] groupIds)
415 throws SystemException {
416
417 rolePersistence.addGroups(roleId, groupIds);
418
419 PermissionCacheUtil.clearCache();
420 }
421
422
429 @Override
430 public void addUserGroups(long userId, long[] groupIds)
431 throws SystemException {
432
433 userPersistence.addGroups(userId, groupIds);
434
435 PermissionCacheUtil.clearCache();
436 }
437
438
449 @Override
450 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
451 public void checkCompanyGroup(long companyId)
452 throws PortalException, SystemException {
453
454 long classNameId = PortalUtil.getClassNameId(Company.class);
455
456 int count = groupPersistence.countByC_C_C(
457 companyId, classNameId, companyId);
458
459 if (count == 0) {
460 long defaultUserId = userLocalService.getDefaultUserId(companyId);
461
462 groupLocalService.addGroup(
463 defaultUserId, Company.class.getName(), companyId,
464 GroupConstants.GLOBAL, null, 0,
465 GroupConstants.GLOBAL_FRIENDLY_URL, false, true, null);
466 }
467 }
468
469
478 @Override
479 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
480 public void checkSystemGroups(long companyId)
481 throws PortalException, SystemException {
482
483 String companyIdHexString = StringUtil.toHexString(companyId);
484
485 for (Group group : groupFinder.findBySystem(companyId)) {
486 _systemGroupsMap.put(
487 companyIdHexString.concat(group.getName()), group);
488 }
489
490 long defaultUserId = userLocalService.getDefaultUserId(companyId);
491
492 String[] systemGroups = PortalUtil.getSystemGroups();
493
494 for (String name : systemGroups) {
495 String groupCacheKey = companyIdHexString.concat(name);
496
497 Group group = _systemGroupsMap.get(groupCacheKey);
498
499 if (group == null) {
500 group = groupPersistence.fetchByC_N(companyId, name);
501 }
502
503 if (group == null) {
504 String className = null;
505 long classPK = 0;
506 int type = GroupConstants.TYPE_SITE_OPEN;
507 String friendlyURL = null;
508 boolean site = true;
509
510 if (name.equals(GroupConstants.CONTROL_PANEL)) {
511 type = GroupConstants.TYPE_SITE_PRIVATE;
512 friendlyURL = GroupConstants.CONTROL_PANEL_FRIENDLY_URL;
513 site = false;
514 }
515 else if (name.equals(GroupConstants.GUEST)) {
516 friendlyURL = "/guest";
517 }
518 else if (name.equals(GroupConstants.USER_PERSONAL_SITE)) {
519 className = UserPersonalSite.class.getName();
520 classPK = defaultUserId;
521 type = GroupConstants.TYPE_SITE_PRIVATE;
522 friendlyURL =
523 GroupConstants.USER_PERSONAL_SITE_FRIENDLY_URL;
524 site = false;
525 }
526
527 group = groupLocalService.addGroup(
528 defaultUserId, className, classPK, name, null, type,
529 friendlyURL, site, true, null);
530
531 if (name.equals(GroupConstants.USER_PERSONAL_SITE)) {
532 initUserPersonalSitePermissions(group);
533 }
534 }
535
536 if (group.isControlPanel()) {
537 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
538 group.getGroupId(), true);
539
540 if (layoutSet.getPageCount() == 0) {
541 addControlPanelLayouts(group);
542 }
543 }
544
545 if (group.getName().equals(GroupConstants.GUEST)) {
546 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
547 group.getGroupId(), false);
548
549 if (layoutSet.getPageCount() == 0) {
550 addDefaultGuestPublicLayouts(group);
551 }
552 }
553
554 _systemGroupsMap.put(groupCacheKey, group);
555 }
556 }
557
558
575 @Override
576 public Group deleteGroup(Group group)
577 throws PortalException, SystemException {
578
579 if (PortalUtil.isSystemGroup(group.getName())) {
580 throw new RequiredGroupException(
581 String.valueOf(group.getGroupId()));
582 }
583
584
585
586 layoutSetBranchLocalService.deleteLayoutSetBranches(
587 group.getGroupId(), true, true);
588
589 layoutSetBranchLocalService.deleteLayoutSetBranches(
590 group.getGroupId(), false, true);
591
592
593
594 ServiceContext serviceContext = new ServiceContext();
595
596 try {
597 layoutSetLocalService.deleteLayoutSet(
598 group.getGroupId(), true, serviceContext);
599 }
600 catch (NoSuchLayoutSetException nslse) {
601 }
602
603 try {
604 layoutSetLocalService.deleteLayoutSet(
605 group.getGroupId(), false, serviceContext);
606 }
607 catch (NoSuchLayoutSetException nslse) {
608 }
609
610
611
612 userGroupRoleLocalService.deleteUserGroupRolesByGroupId(
613 group.getGroupId());
614
615
616
617 userGroupGroupRoleLocalService.deleteUserGroupGroupRolesByGroupId(
618 group.getGroupId());
619
620
621
622 membershipRequestLocalService.deleteMembershipRequests(
623 group.getGroupId());
624
625
626
627 portletPreferencesLocalService.deletePortletPreferences(
628 group.getGroupId(), PortletKeys.PREFS_OWNER_TYPE_GROUP,
629 PortletKeys.PREFS_PLID_SHARED);
630
631
632
633 subscriptionLocalService.deleteSubscriptions(
634 group.getCompanyId(), BlogsEntry.class.getName(),
635 group.getGroupId());
636 subscriptionLocalService.deleteSubscriptions(
637 group.getCompanyId(), JournalArticle.class.getName(),
638 group.getGroupId());
639
640
641
642 teamLocalService.deleteTeams(group.getGroupId());
643
644
645
646 unscheduleStaging(group);
647
648 if (group.hasStagingGroup()) {
649 try {
650 StagingUtil.disableStaging(group, serviceContext);
651 }
652 catch (Exception e) {
653 _log.error(
654 "Unable to disable staging for group " +
655 group.getGroupId());
656 }
657 }
658
659
660
661 ThemeLoader themeLoader = ThemeLoaderFactory.getDefaultThemeLoader();
662
663 if (themeLoader != null) {
664 String themePath =
665 themeLoader.getFileStorage() + StringPool.SLASH +
666 group.getGroupId();
667
668 FileUtil.deltree(themePath + "-private");
669 FileUtil.deltree(themePath + "-public");
670 }
671
672
673
674 deletePortletData(group);
675
676
677
678 if (group.isRegularSite()) {
679 assetEntryLocalService.deleteEntry(
680 Group.class.getName(), group.getGroupId());
681 }
682
683 assetVocabularyLocalService.deleteVocabularies(group.getGroupId());
684
685
686
687 shoppingCartLocalService.deleteGroupCarts(group.getGroupId());
688 shoppingCategoryLocalService.deleteCategories(group.getGroupId());
689 shoppingCouponLocalService.deleteCoupons(group.getGroupId());
690 shoppingOrderLocalService.deleteOrders(group.getGroupId());
691
692
693
694 scFrameworkVersionLocalService.deleteFrameworkVersions(
695 group.getGroupId());
696 scProductEntryLocalService.deleteProductEntries(group.getGroupId());
697
698
699
700 if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
701 List<ResourcePermission> resourcePermissions =
702 resourcePermissionPersistence.findByC_P(
703 group.getCompanyId(), String.valueOf(group.getGroupId()));
704
705 for (ResourcePermission resourcePermission : resourcePermissions) {
706 resourcePermissionLocalService.deleteResourcePermission(
707 resourcePermission);
708 }
709 }
710 else {
711 List<Resource> resources = resourceFinder.findByC_P(
712 group.getCompanyId(), String.valueOf(group.getGroupId()));
713
714 for (Resource resource : resources) {
715 resourceLocalService.deleteResource(resource);
716 }
717 }
718
719 if (!group.isStagingGroup() &&
720 (group.isOrganization() || group.isRegularSite())) {
721
722 resourceLocalService.deleteResource(
723 group.getCompanyId(), Group.class.getName(),
724 ResourceConstants.SCOPE_INDIVIDUAL, group.getGroupId());
725 }
726
727
728
729 if (!group.isStagingGroup() && group.isOrganization() &&
730 group.isSite()) {
731
732 group.setSite(false);
733
734 groupPersistence.update(group, false);
735 }
736 else {
737 groupPersistence.remove(group);
738 }
739
740
741
742 PermissionCacheUtil.clearCache();
743
744 return group;
745 }
746
747
764 @Override
765 public Group deleteGroup(long groupId)
766 throws PortalException, SystemException {
767
768 Group group = groupPersistence.findByPrimaryKey(groupId);
769
770 return deleteGroup(group);
771 }
772
773
782 @Override
783 public Group fetchFriendlyURLGroup(long companyId, String friendlyURL)
784 throws SystemException {
785
786 if (Validator.isNull(friendlyURL)) {
787 return null;
788 }
789
790 friendlyURL = getFriendlyURL(friendlyURL);
791
792 return groupPersistence.fetchByC_F(companyId, friendlyURL);
793 }
794
795
804 @Override
805 @Skip
806 public Group fetchGroup(long companyId, String name)
807 throws SystemException {
808
809 Group group = _systemGroupsMap.get(
810 StringUtil.toHexString(companyId).concat(name));
811
812 if (group != null) {
813 return group;
814 }
815
816 return groupLocalService.loadFetchGroup(companyId, name);
817 }
818
819
827 @Override
828 public Group getCompanyGroup(long companyId)
829 throws PortalException, SystemException {
830
831 long classNameId = PortalUtil.getClassNameId(Company.class);
832
833 return groupPersistence.findByC_C_C(companyId, classNameId, companyId);
834 }
835
836
856 @Override
857 public List<Group> getCompanyGroups(long companyId, int start, int end)
858 throws SystemException {
859
860 return groupPersistence.findByCompanyId(companyId, start, end);
861 }
862
863
870 @Override
871 public int getCompanyGroupsCount(long companyId) throws SystemException {
872 return groupPersistence.countByCompanyId(companyId);
873 }
874
875
885 @Override
886 public Group getFriendlyURLGroup(long companyId, String friendlyURL)
887 throws PortalException, SystemException {
888
889 if (Validator.isNull(friendlyURL)) {
890 throw new NoSuchGroupException();
891 }
892
893 friendlyURL = getFriendlyURL(friendlyURL);
894
895 return groupPersistence.findByC_F(companyId, friendlyURL);
896 }
897
898
907 @Override
908 @ThreadLocalCachable
909 public Group getGroup(long groupId)
910 throws PortalException, SystemException {
911
912 return groupPersistence.findByPrimaryKey(groupId);
913 }
914
915
924 @Override
925 @Skip
926 public Group getGroup(long companyId, String name)
927 throws PortalException, SystemException {
928
929 Group group = _systemGroupsMap.get(
930 StringUtil.toHexString(companyId).concat(name));
931
932 if (group != null) {
933 return group;
934 }
935
936 return groupLocalService.loadGetGroup(companyId, name);
937 }
938
939 @Override
940 public String getGroupDescriptiveName(Group group, Locale locale)
941 throws PortalException, SystemException {
942
943 String name = group.getName();
944
945 if (group.isCompany()) {
946 name = LanguageUtil.get(locale, "global");
947 }
948 else if (group.isControlPanel()) {
949 name = LanguageUtil.get(locale, "control-panel");
950 }
951 else if (group.isLayout()) {
952 Layout layout = layoutLocalService.getLayout(group.getClassPK());
953
954 name = layout.getName(locale);
955 }
956 else if (group.isLayoutPrototype()) {
957 LayoutPrototype layoutPrototype =
958 layoutPrototypeLocalService.getLayoutPrototype(
959 group.getClassPK());
960
961 name = layoutPrototype.getName(locale);
962 }
963 else if (group.isLayoutSetPrototype()) {
964 LayoutSetPrototype layoutSetPrototype =
965 layoutSetPrototypePersistence.findByPrimaryKey(
966 group.getClassPK());
967
968 name = layoutSetPrototype.getName(locale);
969 }
970 else if (group.isOrganization()) {
971 long organizationId = group.getOrganizationId();
972
973 Organization organization =
974 organizationPersistence.findByPrimaryKey(organizationId);
975
976 name = organization.getName();
977 }
978 else if (group.isUser()) {
979 long userId = group.getClassPK();
980
981 User user = userPersistence.findByPrimaryKey(userId);
982
983 name = user.getFullName();
984 }
985 else if (group.isUserGroup()) {
986 long userGroupId = group.getClassPK();
987
988 UserGroup userGroup = userGroupPersistence.findByPrimaryKey(
989 userGroupId);
990
991 name = userGroup.getName();
992 }
993 else if (group.isUserPersonalSite()) {
994 name = LanguageUtil.get(locale, "user-personal-site");
995 }
996 else if (name.equals(GroupConstants.GUEST)) {
997 Company company = companyPersistence.findByPrimaryKey(
998 group.getCompanyId());
999
1000 Account account = company.getAccount();
1001
1002 name = account.getName();
1003 }
1004
1005 return name;
1006 }
1007
1008 @Override
1009 public String getGroupDescriptiveName(long groupId, Locale locale)
1010 throws PortalException, SystemException {
1011
1012 Group group = groupPersistence.findByPrimaryKey(groupId);
1013
1014 return getGroupDescriptiveName(group, locale);
1015 }
1016
1017
1025 @Override
1026 public List<Group> getGroups(long[] groupIds)
1027 throws PortalException, SystemException {
1028
1029 List<Group> groups = new ArrayList<Group>(groupIds.length);
1030
1031 for (long groupId : groupIds) {
1032 Group group = getGroup(groupId);
1033
1034 groups.add(group);
1035 }
1036
1037 return groups;
1038 }
1039
1040
1049 @Override
1050 public Group getLayoutGroup(long companyId, long plid)
1051 throws PortalException, SystemException {
1052
1053 long classNameId = PortalUtil.getClassNameId(Layout.class);
1054
1055 return groupPersistence.findByC_C_C(companyId, classNameId, plid);
1056 }
1057
1058
1067 @Override
1068 public Group getLayoutPrototypeGroup(long companyId, long layoutPrototypeId)
1069 throws PortalException, SystemException {
1070
1071 long classNameId = PortalUtil.getClassNameId(LayoutPrototype.class);
1072
1073 return groupPersistence.findByC_C_C(
1074 companyId, classNameId, layoutPrototypeId);
1075 }
1076
1077
1086 @Override
1087 public Group getLayoutSetPrototypeGroup(
1088 long companyId, long layoutSetPrototypeId)
1089 throws PortalException, SystemException {
1090
1091 long classNameId = PortalUtil.getClassNameId(LayoutSetPrototype.class);
1092
1093 return groupPersistence.findByC_C_C(
1094 companyId, classNameId, layoutSetPrototypeId);
1095 }
1096
1097
1103 @Override
1104 public List<Group> getLiveGroups() throws SystemException {
1105 return groupFinder.findByLiveGroups();
1106 }
1107
1108
1131 @Override
1132 public List<Group> getNoLayoutsGroups(
1133 String className, boolean privateLayout, int start, int end)
1134 throws SystemException {
1135
1136 long classNameId = PortalUtil.getClassNameId(className);
1137
1138 return groupFinder.findByNoLayouts(
1139 classNameId, privateLayout, start, end);
1140 }
1141
1142
1150 @Override
1151 public List<Group> getNullFriendlyURLGroups() throws SystemException {
1152 return groupFinder.findByNullFriendlyURL();
1153 }
1154
1155
1164 @Override
1165 public Group getOrganizationGroup(long companyId, long organizationId)
1166 throws PortalException, SystemException {
1167
1168 long classNameId = PortalUtil.getClassNameId(Organization.class);
1169
1170 return groupPersistence.findByC_C_C(
1171 companyId, classNameId, organizationId);
1172 }
1173
1174
1180 @Override
1181 public List<Group> getOrganizationsGroups(
1182 List<Organization> organizations) {
1183
1184 List<Group> organizationGroups = new ArrayList<Group>();
1185
1186 for (int i = 0; i < organizations.size(); i++) {
1187 Organization organization = organizations.get(i);
1188
1189 Group group = organization.getGroup();
1190
1191 organizationGroups.add(group);
1192 }
1193
1194 return organizationGroups;
1195 }
1196
1197
1204 @Override
1205 public List<Group> getOrganizationsRelatedGroups(
1206 List<Organization> organizations)
1207 throws SystemException {
1208
1209 List<Group> organizationGroups = new ArrayList<Group>();
1210
1211 for (int i = 0; i < organizations.size(); i++) {
1212 Organization organization = organizations.get(i);
1213
1214 List<Group> groups = organizationPersistence.getGroups(
1215 organization.getOrganizationId());
1216
1217 organizationGroups.addAll(groups);
1218 }
1219
1220 return organizationGroups;
1221 }
1222
1223
1230 @Override
1231 public List<Group> getRoleGroups(long roleId) throws SystemException {
1232 return rolePersistence.getGroups(roleId);
1233 }
1234
1235
1243 @Override
1244 public Group getStagingGroup(long liveGroupId)
1245 throws PortalException, SystemException {
1246
1247 return groupPersistence.findByLiveGroupId(liveGroupId);
1248 }
1249
1250
1259 @Override
1260 public Group getUserGroup(long companyId, long userId)
1261 throws PortalException, SystemException {
1262
1263 long classNameId = PortalUtil.getClassNameId(User.class);
1264
1265 return groupPersistence.findByC_C_C(companyId, classNameId, userId);
1266 }
1267
1268
1278 @Override
1279 public Group getUserGroupGroup(long companyId, long userGroupId)
1280 throws PortalException, SystemException {
1281
1282 long classNameId = PortalUtil.getClassNameId(UserGroup.class);
1283
1284 return groupPersistence.findByC_C_C(
1285 companyId, classNameId, userGroupId);
1286 }
1287
1288
1297 @Override
1298 public List<Group> getUserGroups(long userId)
1299 throws PortalException, SystemException {
1300
1301 return getUserGroups(userId, false);
1302 }
1303
1304
1316 @Override
1317 public List<Group> getUserGroups(long userId, boolean inherit)
1318 throws PortalException, SystemException {
1319
1320 return getUserGroups(
1321 userId, inherit, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1322 }
1323
1324
1351 @Override
1352 public List<Group> getUserGroups(
1353 long userId, boolean inherit, int start, int end)
1354 throws PortalException, SystemException {
1355
1356 if (inherit) {
1357 User user = userPersistence.findByPrimaryKey(userId);
1358
1359 LinkedHashMap<String, Object> groupParams =
1360 new LinkedHashMap<String, Object>();
1361
1362 groupParams.put("usersGroups", new Long(userId));
1363
1364 return search(
1365 user.getCompanyId(), null, null, groupParams, start, end);
1366 }
1367 else {
1368 return userPersistence.getGroups(userId, start, end);
1369 }
1370 }
1371
1372
1395 @Override
1396 public List<Group> getUserGroups(long userId, int start, int end)
1397 throws PortalException, SystemException {
1398
1399 return getUserGroups(userId, false, start, end);
1400 }
1401
1402
1411 @Override
1412 public List<Group> getUserGroupsGroups(List<UserGroup> userGroups)
1413 throws PortalException, SystemException {
1414
1415 List<Group> userGroupGroups = new ArrayList<Group>();
1416
1417 for (int i = 0; i < userGroups.size(); i++) {
1418 UserGroup userGroup = userGroups.get(i);
1419
1420 Group group = userGroup.getGroup();
1421
1422 userGroupGroups.add(group);
1423 }
1424
1425 return userGroupGroups;
1426 }
1427
1428
1435 @Override
1436 public List<Group> getUserGroupsRelatedGroups(List<UserGroup> userGroups)
1437 throws SystemException {
1438
1439 List<Group> userGroupGroups = new ArrayList<Group>();
1440
1441 for (int i = 0; i < userGroups.size(); i++) {
1442 UserGroup userGroup = userGroups.get(i);
1443
1444 List<Group> groups = userGroupPersistence.getGroups(
1445 userGroup.getUserGroupId());
1446
1447 userGroupGroups.addAll(groups);
1448 }
1449
1450 return userGroupGroups;
1451 }
1452
1453
1479 @Override
1480 public List<Group> getUserOrganizationsGroups(
1481 long userId, int start, int end)
1482 throws PortalException, SystemException {
1483
1484 List<Group> userOrgsGroups = new UniqueList<Group>();
1485
1486 List<Organization> userOrgs =
1487 organizationLocalService.getUserOrganizations(userId, start, end);
1488
1489 for (Organization organization : userOrgs) {
1490 userOrgsGroups.add(0, organization.getGroup());
1491
1492 if (!PropsValues.ORGANIZATIONS_MEMBERSHIP_STRICT) {
1493 for (Organization ancestorOrganization :
1494 organization.getAncestors()) {
1495
1496 userOrgsGroups.add(0, ancestorOrganization.getGroup());
1497 }
1498 }
1499 }
1500
1501 return userOrgsGroups;
1502 }
1503
1504
1513 @Override
1514 public boolean hasRoleGroup(long roleId, long groupId)
1515 throws SystemException {
1516
1517 return rolePersistence.containsGroup(roleId, groupId);
1518 }
1519
1520
1528 @Override
1529 public boolean hasStagingGroup(long liveGroupId) throws SystemException {
1530 if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
1531 return true;
1532 }
1533 else {
1534 return false;
1535 }
1536 }
1537
1538
1549 @Override
1550 public boolean hasUserGroup(long userId, long groupId)
1551 throws SystemException {
1552
1553 return hasUserGroup(userId, groupId, true);
1554 }
1555
1556
1569 @Override
1570 public boolean hasUserGroup(long userId, long groupId, boolean inherit)
1571 throws SystemException {
1572
1573 if (groupFinder.countByG_U(groupId, userId, inherit) > 0) {
1574 return true;
1575 }
1576 else {
1577 return false;
1578 }
1579 }
1580
1581 @Override
1582 public Group loadFetchGroup(long companyId, String name)
1583 throws SystemException {
1584
1585 return groupPersistence.fetchByC_N(companyId, name);
1586 }
1587
1588 @Override
1589 public Group loadGetGroup(long companyId, String name)
1590 throws PortalException, SystemException {
1591
1592 return groupPersistence.findByC_N(companyId, name);
1593 }
1594
1595 @Override
1596 public List<Group> search(
1597 long companyId, LinkedHashMap<String, Object> params, int start,
1598 int end)
1599 throws SystemException {
1600
1601 return groupFinder.findByCompanyId(
1602 companyId, params, start, end, new GroupNameComparator(true));
1603 }
1604
1605
1641 @Override
1642 public List<Group> search(
1643 long companyId, long[] classNameIds, String name,
1644 String description, LinkedHashMap<String, Object> params, int start,
1645 int end)
1646 throws SystemException {
1647
1648 return search(
1649 companyId, classNameIds, name, description, params, start, end,
1650 null);
1651 }
1652
1653
1690 @Override
1691 public List<Group> search(
1692 long companyId, long[] classNameIds, String name,
1693 String description, LinkedHashMap<String, Object> params, int start,
1694 int end, OrderByComparator obc)
1695 throws SystemException {
1696
1697 if (obc == null) {
1698 obc = new GroupNameComparator(true);
1699 }
1700
1701 String realName = getRealName(companyId, name);
1702
1703 return groupFinder.findByC_C_N_D(
1704 companyId, classNameIds, name, realName, description, params, start,
1705 end, obc);
1706 }
1707
1708
1740 @Override
1741 public List<Group> search(
1742 long companyId, String name, String description,
1743 LinkedHashMap<String, Object> params, int start, int end)
1744 throws SystemException {
1745
1746 return search(companyId, name, description, params, start, end, null);
1747 }
1748
1749
1783 @Override
1784 public List<Group> search(
1785 long companyId, String name, String description,
1786 LinkedHashMap<String, Object> params, int start, int end,
1787 OrderByComparator obc)
1788 throws SystemException {
1789
1790 if (obc == null) {
1791 obc = new GroupNameComparator(true);
1792 }
1793
1794 String realName = getRealName(companyId, name);
1795
1796 return groupFinder.findByC_N_D(
1797 companyId, name, realName, description, params, start, end, obc);
1798 }
1799
1800
1820 @Override
1821 @ThreadLocalCachable
1822 public int searchCount(
1823 long companyId, long[] classNameIds, String name,
1824 String description, LinkedHashMap<String, Object> params)
1825 throws SystemException {
1826
1827 String realName = getRealName(companyId, name);
1828
1829 return groupFinder.countByC_C_N_D(
1830 companyId, classNameIds, name, realName, description, params);
1831 }
1832
1833
1852 @Override
1853 @ThreadLocalCachable
1854 public int searchCount(
1855 long companyId, String name, String description,
1856 LinkedHashMap<String, Object> params)
1857 throws SystemException {
1858
1859 String realName = getRealName(companyId, name);
1860
1861 return groupFinder.countByC_N_D(
1862 companyId, name, realName, description, params);
1863 }
1864
1865
1873 @Override
1874 public void setRoleGroups(long roleId, long[] groupIds)
1875 throws SystemException {
1876
1877 rolePersistence.setGroups(roleId, groupIds);
1878
1879 PermissionCacheUtil.clearCache();
1880 }
1881
1882
1889 @Override
1890 public void unsetRoleGroups(long roleId, long[] groupIds)
1891 throws SystemException {
1892
1893 rolePersistence.removeGroups(roleId, groupIds);
1894
1895 PermissionCacheUtil.clearCache();
1896 }
1897
1898
1905 @Override
1906 public void unsetUserGroups(long userId, long[] groupIds)
1907 throws SystemException {
1908
1909 userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
1910
1911 userPersistence.removeGroups(userId, groupIds);
1912
1913 PermissionCacheUtil.clearCache();
1914 }
1915
1916
1927 @Override
1928 public void updateAsset(
1929 long userId, Group group, long[] assetCategoryIds,
1930 String[] assetTagNames)
1931 throws PortalException, SystemException {
1932
1933 User user = userPersistence.findByPrimaryKey(userId);
1934
1935 Company company = companyPersistence.findByPrimaryKey(
1936 user.getCompanyId());
1937
1938 Group companyGroup = company.getGroup();
1939
1940 assetEntryLocalService.updateEntry(
1941 userId, companyGroup.getGroupId(), null, null,
1942 Group.class.getName(), group.getGroupId(), null, 0,
1943 assetCategoryIds, assetTagNames, false, null, null, null, null,
1944 null, group.getDescriptiveName(), group.getDescription(), null,
1945 null, null, 0, 0, null, false);
1946 }
1947
1948
1960 @Override
1961 public Group updateFriendlyURL(long groupId, String friendlyURL)
1962 throws PortalException, SystemException {
1963
1964 Group group = groupPersistence.findByPrimaryKey(groupId);
1965
1966 if (group.isUser()) {
1967 User user = userPersistence.findByPrimaryKey(group.getClassPK());
1968
1969 friendlyURL = StringPool.SLASH + user.getScreenName();
1970
1971 if (group.getFriendlyURL().equals(friendlyURL)) {
1972 return group;
1973 }
1974 }
1975
1976 friendlyURL = getFriendlyURL(
1977 group.getCompanyId(), groupId, group.getClassNameId(),
1978 group.getClassPK(), StringPool.BLANK, friendlyURL);
1979
1980 validateFriendlyURL(
1981 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
1982 group.getClassPK(), friendlyURL);
1983
1984 group.setFriendlyURL(friendlyURL);
1985
1986 groupPersistence.update(group, false);
1987
1988 return group;
1989 }
1990
1991
2002 @Override
2003 public Group updateGroup(long groupId, String typeSettings)
2004 throws PortalException, SystemException {
2005
2006 Group group = groupPersistence.findByPrimaryKey(groupId);
2007
2008 group.setTypeSettings(typeSettings);
2009
2010 groupPersistence.update(group, false);
2011
2012 return group;
2013 }
2014
2015
2036 @Override
2037 public Group updateGroup(
2038 long groupId, String name, String description, int type,
2039 String friendlyURL, boolean active, ServiceContext serviceContext)
2040 throws PortalException, SystemException {
2041
2042 Group group = groupPersistence.findByPrimaryKey(groupId);
2043
2044 String className = group.getClassName();
2045 long classNameId = group.getClassNameId();
2046 long classPK = group.getClassPK();
2047 friendlyURL = getFriendlyURL(
2048 group.getCompanyId(), groupId, classNameId, classPK,
2049 StringPool.BLANK, friendlyURL);
2050
2051 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
2052 validateName(
2053 group.getGroupId(), group.getCompanyId(), name, group.isSite());
2054 }
2055 else if (className.equals(Organization.class.getName())) {
2056 Organization organization =
2057 organizationPersistence.findByPrimaryKey(classPK);
2058
2059 name = getOrgGroupName(organization.getName());
2060 }
2061 else if (!GroupConstants.USER_PERSONAL_SITE.equals(name)) {
2062 name = String.valueOf(classPK);
2063 }
2064
2065 if (PortalUtil.isSystemGroup(group.getName()) &&
2066 !group.getName().equals(name)) {
2067
2068 throw new RequiredGroupException();
2069 }
2070
2071 validateFriendlyURL(
2072 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
2073 group.getClassPK(), friendlyURL);
2074
2075 group.setName(name);
2076 group.setDescription(description);
2077 group.setType(type);
2078 group.setFriendlyURL(friendlyURL);
2079 group.setActive(active);
2080
2081 if ((serviceContext != null) && group.isSite()) {
2082 group.setExpandoBridgeAttributes(serviceContext);
2083 }
2084
2085 groupPersistence.update(group, false);
2086
2087
2088
2089 if ((serviceContext == null) || !group.isSite()) {
2090 return group;
2091 }
2092
2093 User user = null;
2094
2095 try {
2096 user = userPersistence.findByPrimaryKey(group.getCreatorUserId());
2097
2098 }
2099 catch (NoSuchUserException nsue1) {
2100 try {
2101 user = userPersistence.findByPrimaryKey(
2102 serviceContext.getUserId());
2103 }
2104 catch (NoSuchUserException nsue2) {
2105 user = userLocalService.getDefaultUser(group.getCompanyId());
2106 }
2107 }
2108
2109 updateAsset(
2110 user.getUserId(), group, serviceContext.getAssetCategoryIds(),
2111 serviceContext.getAssetTagNames());
2112
2113 return group;
2114 }
2115
2116
2126 @Override
2127 public Group updateSite(long groupId, boolean site)
2128 throws PortalException, SystemException {
2129
2130 Group group = groupPersistence.findByPrimaryKey(groupId);
2131
2132 if (!group.isOrganization()) {
2133 return group;
2134 }
2135
2136 group.setSite(site);
2137
2138 groupPersistence.update(group, false);
2139
2140 return group;
2141 }
2142
2143 protected void addControlPanelLayouts(Group group)
2144 throws PortalException, SystemException {
2145
2146 long defaultUserId = userLocalService.getDefaultUserId(
2147 group.getCompanyId());
2148
2149 String friendlyURL = getFriendlyURL(
2150 PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
2151
2152 ServiceContext serviceContext = new ServiceContext();
2153
2154 layoutLocalService.addLayout(
2155 defaultUserId, group.getGroupId(), true,
2156 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
2157 PropsValues.CONTROL_PANEL_LAYOUT_NAME, StringPool.BLANK,
2158 StringPool.BLANK, LayoutConstants.TYPE_CONTROL_PANEL, false,
2159 friendlyURL, serviceContext);
2160 }
2161
2162 protected void addDefaultGuestPublicLayoutByProperties(Group group)
2163 throws PortalException, SystemException {
2164
2165 long defaultUserId = userLocalService.getDefaultUserId(
2166 group.getCompanyId());
2167 String friendlyURL = getFriendlyURL(
2168 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
2169
2170 ServiceContext serviceContext = new ServiceContext();
2171
2172 Layout layout = layoutLocalService.addLayout(
2173 defaultUserId, group.getGroupId(), false,
2174 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
2175 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
2176 StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL,
2177 serviceContext);
2178
2179 LayoutTypePortlet layoutTypePortlet =
2180 (LayoutTypePortlet)layout.getLayoutType();
2181
2182 layoutTypePortlet.setLayoutTemplateId(
2183 0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
2184
2185 for (int i = 0; i < 10; i++) {
2186 String columnId = "column-" + i;
2187 String portletIds = PropsUtil.get(
2188 PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_COLUMN + i);
2189
2190 layoutTypePortlet.addPortletIds(
2191 0, StringUtil.split(portletIds), columnId, false);
2192 }
2193
2194 layoutLocalService.updateLayout(
2195 layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
2196 layout.getTypeSettings());
2197
2198 boolean updateLayoutSet = false;
2199
2200 LayoutSet layoutSet = layout.getLayoutSet();
2201
2202 if (Validator.isNotNull(
2203 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
2204
2205 layoutSet.setThemeId(
2206 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
2207
2208 updateLayoutSet = true;
2209 }
2210
2211 if (Validator.isNotNull(
2212 PropsValues.
2213 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
2214
2215 layoutSet.setColorSchemeId(
2216 PropsValues.
2217 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
2218
2219 updateLayoutSet = true;
2220 }
2221
2222 if (Validator.isNotNull(
2223 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
2224
2225 layoutSet.setWapThemeId(
2226 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
2227
2228 updateLayoutSet = true;
2229 }
2230
2231 if (Validator.isNotNull(
2232 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
2233
2234 layoutSet.setWapColorSchemeId(
2235 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
2236
2237 updateLayoutSet = true;
2238 }
2239
2240 if (updateLayoutSet) {
2241 layoutSetLocalService.updateLayoutSet(layoutSet);
2242 }
2243 }
2244
2245 protected void addDefaultGuestPublicLayouts(Group group)
2246 throws PortalException, SystemException {
2247
2248 if (publicLARFile != null) {
2249 addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
2250 }
2251 else {
2252 addDefaultGuestPublicLayoutByProperties(group);
2253 }
2254 }
2255
2256 protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
2257 throws PortalException, SystemException {
2258
2259 long defaultUserId = userLocalService.getDefaultUserId(
2260 group.getCompanyId());
2261
2262 Map<String, String[]> parameterMap = new HashMap<String, String[]>();
2263
2264 parameterMap.put(
2265 PortletDataHandlerKeys.CATEGORIES,
2266 new String[] {Boolean.TRUE.toString()});
2267 parameterMap.put(
2268 PortletDataHandlerKeys.PERMISSIONS,
2269 new String[] {Boolean.TRUE.toString()});
2270 parameterMap.put(
2271 PortletDataHandlerKeys.PORTLET_DATA,
2272 new String[] {Boolean.TRUE.toString()});
2273 parameterMap.put(
2274 PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
2275 new String[] {Boolean.TRUE.toString()});
2276 parameterMap.put(
2277 PortletDataHandlerKeys.PORTLET_SETUP,
2278 new String[] {Boolean.TRUE.toString()});
2279 parameterMap.put(
2280 PortletDataHandlerKeys.USER_PERMISSIONS,
2281 new String[] {Boolean.FALSE.toString()});
2282
2283 layoutLocalService.importLayouts(
2284 defaultUserId, group.getGroupId(), false, parameterMap, larFile);
2285 }
2286
2287 protected void deletePortletData(Group group)
2288 throws PortalException, SystemException {
2289
2290 List<Portlet> portlets = portletLocalService.getPortlets(
2291 group.getCompanyId());
2292
2293 for (Portlet portlet : portlets) {
2294 if (!portlet.isActive()) {
2295 continue;
2296 }
2297
2298 PortletDataHandler portletDataHandler =
2299 portlet.getPortletDataHandlerInstance();
2300
2301 if (portletDataHandler == null) {
2302 continue;
2303 }
2304
2305 PortletDataContext portletDataContext = new PortletDataContextImpl(
2306 group.getCompanyId(), group.getGroupId(), null,
2307 new HashSet<String>(), null, null, null);
2308
2309
2310
2311
2312
2313
2314
2315
2316 portletDataHandler.deleteData(
2317 portletDataContext, portlet.getPortletId(), null);
2318
2325 }
2326 }
2327
2328 protected String getFriendlyURL(
2329 long companyId, long groupId, long classNameId, long classPK,
2330 String friendlyName, String friendlyURL)
2331 throws PortalException, SystemException {
2332
2333 friendlyURL = getFriendlyURL(friendlyURL);
2334
2335 if (Validator.isNotNull(friendlyURL)) {
2336 return friendlyURL;
2337 }
2338
2339 friendlyURL = StringPool.SLASH + getFriendlyURL(friendlyName);
2340
2341 String originalFriendlyURL = friendlyURL;
2342
2343 for (int i = 1;; i++) {
2344 try {
2345 validateFriendlyURL(
2346 companyId, groupId, classNameId, classPK, friendlyURL);
2347
2348 break;
2349 }
2350 catch (GroupFriendlyURLException gfurle) {
2351 int type = gfurle.getType();
2352
2353 if (type == GroupFriendlyURLException.DUPLICATE) {
2354 friendlyURL = originalFriendlyURL + i;
2355 }
2356 else {
2357 friendlyURL = StringPool.SLASH + classPK;
2358
2359 break;
2360 }
2361 }
2362 }
2363
2364 return friendlyURL;
2365 }
2366
2367 protected String getFriendlyURL(String friendlyURL) {
2368 return FriendlyURLNormalizerUtil.normalize(friendlyURL);
2369 }
2370
2371 protected String getOrgGroupName(String name) {
2372 return name + ORGANIZATION_NAME_SUFFIX;
2373 }
2374
2375 protected String getRealName(long companyId, String name)
2376 throws SystemException {
2377
2378 if (Validator.isNull(name)) {
2379 return name;
2380 }
2381
2382 String realName = name;
2383
2384 try {
2385 Company company = companyLocalService.getCompany(companyId);
2386
2387 Account account = company.getAccount();
2388
2389 String companyName = account.getName();
2390
2391 name = StringUtil.replace(
2392 name, StringPool.PERCENT, StringPool.BLANK);
2393
2394 if (companyName.contains(name)) {
2395 realName =
2396 StringPool.PERCENT + GroupConstants.GUEST +
2397 StringPool.PERCENT;
2398 }
2399 }
2400 catch (PortalException pe) {
2401 }
2402
2403 return realName;
2404 }
2405
2406 protected void initImportLARFile() {
2407 String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
2408
2409 if (_log.isDebugEnabled()) {
2410 _log.debug("Reading public LAR file " + publicLARFileName);
2411 }
2412
2413 if (Validator.isNotNull(publicLARFileName)) {
2414 publicLARFile = new File(publicLARFileName);
2415
2416 if (!publicLARFile.exists()) {
2417 _log.error(
2418 "Public LAR file " + publicLARFile + " does not exist");
2419
2420 publicLARFile = null;
2421 }
2422 else {
2423 if (_log.isDebugEnabled()) {
2424 _log.debug("Using public LAR file " + publicLARFileName);
2425 }
2426 }
2427 }
2428 }
2429
2430 protected void initUserPersonalSitePermissions(Group group)
2431 throws PortalException, SystemException {
2432
2433
2434
2435 Role role = roleLocalService.getRole(
2436 group.getCompanyId(), RoleConstants.USER);
2437
2438 setCompanyPermissions(
2439 role, PortletKeys.PORTAL,
2440 new String[] {ActionKeys.VIEW_CONTROL_PANEL});
2441
2442 List<Portlet> portlets = portletLocalService.getPortlets(
2443 group.getCompanyId(), false, false);
2444
2445 for (Portlet portlet : portlets) {
2446 setRolePermissions(
2447 group, role, portlet.getPortletId(),
2448 new String[] {ActionKeys.VIEW});
2449 }
2450
2451 setRolePermissions(
2452 group, role, Layout.class.getName(),
2453 new String[] {ActionKeys.VIEW});
2454
2455 setRolePermissions(
2456 group, role, "com.liferay.portlet.blogs",
2457 new String[] {
2458 ActionKeys.ADD_ENTRY, ActionKeys.PERMISSIONS,
2459 ActionKeys.SUBSCRIBE});
2460
2461 setRolePermissions(
2462 group, role, "com.liferay.portlet.calendar",
2463 new String[] {
2464 ActionKeys.ADD_EVENT, ActionKeys.EXPORT_ALL_EVENTS,
2465 ActionKeys.PERMISSIONS});
2466
2467
2468
2469 role = roleLocalService.getRole(
2470 group.getCompanyId(), RoleConstants.POWER_USER);
2471
2472 for (Portlet portlet : portlets) {
2473 List<String> actions =
2474 ResourceActionsUtil.getPortletResourceActions(
2475 portlet.getPortletId());
2476
2477 String controlPanelEntryCategory = GetterUtil.getString(
2478 portlet.getControlPanelEntryCategory());
2479
2480 if (actions.contains(ActionKeys.ACCESS_IN_CONTROL_PANEL) &&
2481 controlPanelEntryCategory.equals(PortletCategoryKeys.CONTENT)) {
2482
2483 setRolePermissions(
2484 group, role, portlet.getPortletId(),
2485 new String[] {ActionKeys.ACCESS_IN_CONTROL_PANEL});
2486 }
2487 }
2488
2489 setRolePermissions(
2490 group, role, Group.class.getName(),
2491 new String[] {ActionKeys.MANAGE_LAYOUTS});
2492
2493 setRolePermissions(group, role, "com.liferay.portlet.asset");
2494 setRolePermissions(group, role, "com.liferay.portlet.blogs");
2495 setRolePermissions(group, role, "com.liferay.portlet.bookmarks");
2496 setRolePermissions(group, role, "com.liferay.portlet.calendar");
2497 setRolePermissions(group, role, "com.liferay.portlet.documentlibrary");
2498 setRolePermissions(group, role, "com.liferay.portlet.imagegallery");
2499 setRolePermissions(group, role, "com.liferay.portlet.messageboards");
2500 setRolePermissions(group, role, "com.liferay.portlet.polls");
2501 setRolePermissions(group, role, "com.liferay.portlet.wiki");
2502 }
2503
2504 protected boolean isStaging(ServiceContext serviceContext) {
2505 if (serviceContext != null) {
2506 return ParamUtil.getBoolean(serviceContext, "staging");
2507 }
2508
2509 return false;
2510 }
2511
2512 protected void setCompanyPermissions(
2513 Role role, String name, String[] actionIds)
2514 throws PortalException, SystemException {
2515
2516 if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
2517 if (resourceBlockLocalService.isSupported(name)) {
2518 resourceBlockLocalService.setCompanyScopePermissions(
2519 role.getCompanyId(), name, role.getRoleId(),
2520 Arrays.asList(actionIds));
2521 }
2522 else {
2523 resourcePermissionLocalService.setResourcePermissions(
2524 role.getCompanyId(), name, ResourceConstants.SCOPE_COMPANY,
2525 String.valueOf(role.getCompanyId()), role.getRoleId(),
2526 actionIds);
2527 }
2528 }
2529 else {
2530 permissionLocalService.setRolePermissions(
2531 role.getRoleId(), role.getCompanyId(), name,
2532 ResourceConstants.SCOPE_COMPANY,
2533 String.valueOf(role.getCompanyId()), actionIds);
2534 }
2535 }
2536
2537 protected void setRolePermissions(Group group, Role role, String name)
2538 throws PortalException, SystemException {
2539
2540 List<String> actions = ResourceActionsUtil.getModelResourceActions(
2541 name);
2542
2543 setRolePermissions(
2544 group, role, name, actions.toArray(new String[actions.size()]));
2545 }
2546
2547 protected void setRolePermissions(
2548 Group group, Role role, String name, String[] actionIds)
2549 throws PortalException, SystemException {
2550
2551 if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
2552 if (resourceBlockLocalService.isSupported(name)) {
2553 resourceBlockLocalService.setGroupScopePermissions(
2554 role.getCompanyId(), group.getGroupId(), name,
2555 role.getRoleId(), Arrays.asList(actionIds));
2556 }
2557 else {
2558 resourcePermissionLocalService.setResourcePermissions(
2559 group.getCompanyId(), name, ResourceConstants.SCOPE_GROUP,
2560 String.valueOf(group.getGroupId()), role.getRoleId(),
2561 actionIds);
2562 }
2563 }
2564 else {
2565 permissionLocalService.setRolePermissions(
2566 role.getRoleId(), group.getCompanyId(), name,
2567 ResourceConstants.SCOPE_GROUP,
2568 String.valueOf(group.getGroupId()), actionIds);
2569 }
2570 }
2571
2572 protected void unscheduleStaging(Group group) {
2573 try {
2574
2575
2576
2577 String groupName = StagingUtil.getSchedulerGroupName(
2578 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
2579
2580 SchedulerEngineHelperUtil.delete(groupName, StorageType.PERSISTED);
2581
2582 long liveGroupId = 0;
2583 long stagingGroupId = 0;
2584
2585 if (group.isStagingGroup()) {
2586 liveGroupId = group.getLiveGroupId();
2587
2588 stagingGroupId = group.getGroupId();
2589 }
2590 else if (group.hasStagingGroup()) {
2591 liveGroupId = group.getGroupId();
2592
2593 stagingGroupId = group.getStagingGroup().getGroupId();
2594 }
2595
2596 if ((liveGroupId != 0) && (stagingGroupId != 0)) {
2597
2598
2599
2600 groupName = StagingUtil.getSchedulerGroupName(
2601 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
2602
2603 SchedulerEngineHelperUtil.delete(
2604 groupName, StorageType.PERSISTED);
2605
2606
2607
2608 groupName = StagingUtil.getSchedulerGroupName(
2609 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
2610
2611 SchedulerEngineHelperUtil.delete(
2612 groupName, StorageType.PERSISTED);
2613 }
2614 }
2615 catch (Exception e) {
2616 _log.error(
2617 "Unable to unschedule events for group: " + group.getGroupId());
2618 }
2619 }
2620
2621 protected void validateFriendlyURL(
2622 long companyId, long groupId, long classNameId, long classPK,
2623 String friendlyURL)
2624 throws PortalException, SystemException {
2625
2626 Company company = companyPersistence.findByPrimaryKey(companyId);
2627
2628 if (company.isSystem()) {
2629 return;
2630 }
2631
2632 if (Validator.isNull(friendlyURL)) {
2633 return;
2634 }
2635
2636 int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
2637
2638 if (exceptionType != -1) {
2639 throw new GroupFriendlyURLException(exceptionType);
2640 }
2641
2642 Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
2643
2644 if ((group != null) && (group.getGroupId() != groupId)) {
2645 throw new GroupFriendlyURLException(
2646 GroupFriendlyURLException.DUPLICATE);
2647 }
2648
2649 String groupIdFriendlyURL = friendlyURL.substring(1);
2650
2651 if (Validator.isNumber(groupIdFriendlyURL)) {
2652 long groupClassNameId = PortalUtil.getClassNameId(Group.class);
2653
2654 if (((classNameId != groupClassNameId) &&
2655 !groupIdFriendlyURL.equals(String.valueOf(classPK)) &&
2656 !PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC) ||
2657 ((classNameId == groupClassNameId) &&
2658 !groupIdFriendlyURL.equals(String.valueOf(groupId)))) {
2659
2660 GroupFriendlyURLException gfurle =
2661 new GroupFriendlyURLException(
2662 GroupFriendlyURLException.POSSIBLE_DUPLICATE);
2663
2664 gfurle.setKeywordConflict(groupIdFriendlyURL);
2665
2666 throw gfurle;
2667 }
2668 }
2669
2670 String screenName = friendlyURL.substring(1);
2671
2672 User user = userPersistence.fetchByC_SN(companyId, screenName);
2673
2674 if (user != null) {
2675 long userClassNameId = PortalUtil.getClassNameId(User.class);
2676
2677 if ((classNameId == userClassNameId) &&
2678 (classPK == user.getUserId())) {
2679 }
2680 else {
2681 throw new GroupFriendlyURLException(
2682 GroupFriendlyURLException.DUPLICATE);
2683 }
2684 }
2685
2686 if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
2687 throw new GroupFriendlyURLException(
2688 GroupFriendlyURLException.TOO_DEEP);
2689 }
2690 }
2691
2692 protected void validateName(
2693 long groupId, long companyId, String name, boolean site)
2694 throws PortalException, SystemException {
2695
2696 if (Validator.isNull(name) || Validator.isNumber(name) ||
2697 name.contains(StringPool.STAR) ||
2698 name.contains(ORGANIZATION_NAME_SUFFIX)) {
2699
2700 throw new GroupNameException();
2701 }
2702
2703 try {
2704 Group group = groupFinder.findByC_N(companyId, name);
2705
2706 if ((groupId <= 0) || (group.getGroupId() != groupId)) {
2707 throw new DuplicateGroupException();
2708 }
2709 }
2710 catch (NoSuchGroupException nsge) {
2711 }
2712
2713 if (site) {
2714 Company company = companyLocalService.getCompany(companyId);
2715
2716 if (name.equals(company.getName())) {
2717 throw new DuplicateGroupException();
2718 }
2719 }
2720 }
2721
2722 protected File publicLARFile;
2723
2724 private static Log _log = LogFactoryUtil.getLog(
2725 GroupLocalServiceImpl.class);
2726
2727 private Map<String, Group> _systemGroupsMap = new HashMap<String, Group>();
2728
2729 }