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.GroupParentException;
021 import com.liferay.portal.LocaleException;
022 import com.liferay.portal.NoSuchGroupException;
023 import com.liferay.portal.NoSuchLayoutSetException;
024 import com.liferay.portal.PendingBackgroundTaskException;
025 import com.liferay.portal.RequiredGroupException;
026 import com.liferay.portal.kernel.backgroundtask.BackgroundTaskConstants;
027 import com.liferay.portal.kernel.cache.ThreadLocalCachable;
028 import com.liferay.portal.kernel.dao.orm.QueryUtil;
029 import com.liferay.portal.kernel.exception.PortalException;
030 import com.liferay.portal.kernel.exception.SystemException;
031 import com.liferay.portal.kernel.language.LanguageUtil;
032 import com.liferay.portal.kernel.lar.PortletDataContext;
033 import com.liferay.portal.kernel.lar.PortletDataContextFactoryUtil;
034 import com.liferay.portal.kernel.lar.PortletDataHandler;
035 import com.liferay.portal.kernel.lar.PortletDataHandlerKeys;
036 import com.liferay.portal.kernel.log.Log;
037 import com.liferay.portal.kernel.log.LogFactoryUtil;
038 import com.liferay.portal.kernel.messaging.DestinationNames;
039 import com.liferay.portal.kernel.scheduler.SchedulerEngineHelperUtil;
040 import com.liferay.portal.kernel.scheduler.StorageType;
041 import com.liferay.portal.kernel.spring.aop.Skip;
042 import com.liferay.portal.kernel.staging.StagingConstants;
043 import com.liferay.portal.kernel.staging.StagingUtil;
044 import com.liferay.portal.kernel.transaction.Propagation;
045 import com.liferay.portal.kernel.transaction.Transactional;
046 import com.liferay.portal.kernel.util.ArrayUtil;
047 import com.liferay.portal.kernel.util.CharPool;
048 import com.liferay.portal.kernel.util.FileUtil;
049 import com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil;
050 import com.liferay.portal.kernel.util.GetterUtil;
051 import com.liferay.portal.kernel.util.GroupThreadLocal;
052 import com.liferay.portal.kernel.util.ListUtil;
053 import com.liferay.portal.kernel.util.LocaleUtil;
054 import com.liferay.portal.kernel.util.MapUtil;
055 import com.liferay.portal.kernel.util.OrderByComparator;
056 import com.liferay.portal.kernel.util.ParamUtil;
057 import com.liferay.portal.kernel.util.PropsKeys;
058 import com.liferay.portal.kernel.util.StringPool;
059 import com.liferay.portal.kernel.util.StringUtil;
060 import com.liferay.portal.kernel.util.UnicodeProperties;
061 import com.liferay.portal.kernel.util.UniqueList;
062 import com.liferay.portal.kernel.util.Validator;
063 import com.liferay.portal.kernel.workflow.WorkflowHandler;
064 import com.liferay.portal.kernel.workflow.WorkflowHandlerRegistryUtil;
065 import com.liferay.portal.kernel.zip.ZipWriter;
066 import com.liferay.portal.model.Account;
067 import com.liferay.portal.model.BackgroundTask;
068 import com.liferay.portal.model.Company;
069 import com.liferay.portal.model.Group;
070 import com.liferay.portal.model.GroupConstants;
071 import com.liferay.portal.model.Layout;
072 import com.liferay.portal.model.LayoutConstants;
073 import com.liferay.portal.model.LayoutPrototype;
074 import com.liferay.portal.model.LayoutSet;
075 import com.liferay.portal.model.LayoutSetPrototype;
076 import com.liferay.portal.model.LayoutTypePortlet;
077 import com.liferay.portal.model.Organization;
078 import com.liferay.portal.model.Portlet;
079 import com.liferay.portal.model.ResourceConstants;
080 import com.liferay.portal.model.ResourcePermission;
081 import com.liferay.portal.model.Role;
082 import com.liferay.portal.model.RoleConstants;
083 import com.liferay.portal.model.User;
084 import com.liferay.portal.model.UserGroup;
085 import com.liferay.portal.model.UserGroupRole;
086 import com.liferay.portal.model.UserPersonalSite;
087 import com.liferay.portal.model.WorkflowDefinitionLink;
088 import com.liferay.portal.model.impl.LayoutImpl;
089 import com.liferay.portal.security.auth.CompanyThreadLocal;
090 import com.liferay.portal.security.permission.ActionKeys;
091 import com.liferay.portal.security.permission.PermissionCacheUtil;
092 import com.liferay.portal.security.permission.ResourceActionsUtil;
093 import com.liferay.portal.service.ServiceContext;
094 import com.liferay.portal.service.base.GroupLocalServiceBaseImpl;
095 import com.liferay.portal.theme.ThemeLoader;
096 import com.liferay.portal.theme.ThemeLoaderFactory;
097 import com.liferay.portal.util.PortalUtil;
098 import com.liferay.portal.util.PortletCategoryKeys;
099 import com.liferay.portal.util.PortletKeys;
100 import com.liferay.portal.util.PropsUtil;
101 import com.liferay.portal.util.PropsValues;
102 import com.liferay.portal.util.comparator.GroupNameComparator;
103 import com.liferay.portlet.blogs.model.BlogsEntry;
104 import com.liferay.portlet.journal.model.JournalArticle;
105 import com.liferay.util.dao.orm.CustomSQLUtil;
106
107 import java.io.File;
108
109 import java.util.ArrayList;
110 import java.util.Arrays;
111 import java.util.Collections;
112 import java.util.Date;
113 import java.util.HashMap;
114 import java.util.HashSet;
115 import java.util.Iterator;
116 import java.util.LinkedHashMap;
117 import java.util.List;
118 import java.util.Locale;
119 import java.util.Map;
120 import java.util.Set;
121
122
196 public class GroupLocalServiceImpl extends GroupLocalServiceBaseImpl {
197
198 public static final String ORGANIZATION_NAME_SUFFIX = " LFR_ORGANIZATION";
199
200
203 public GroupLocalServiceImpl() {
204 initImportLARFile();
205 }
206
207
233 @Override
234 public Group addGroup(
235 long userId, long parentGroupId, String className, long classPK,
236 long liveGroupId, String name, String description, int type,
237 boolean manualMembership, int membershipRestriction,
238 String friendlyURL, boolean site, boolean active,
239 ServiceContext serviceContext)
240 throws PortalException, SystemException {
241
242
243
244 User user = userPersistence.findByPrimaryKey(userId);
245 className = GetterUtil.getString(className);
246 long classNameId = PortalUtil.getClassNameId(className);
247 String friendlyName = name;
248
249 long groupId = 0;
250
251 while (true) {
252 groupId = counterLocalService.increment();
253
254 User screenNameUser = userPersistence.fetchByC_SN(
255 user.getCompanyId(), String.valueOf(groupId));
256
257 if (screenNameUser == null) {
258 break;
259 }
260 }
261
262 boolean staging = isStaging(serviceContext);
263
264 long groupClassNameId = PortalUtil.getClassNameId(Group.class);
265
266 if (((classNameId <= 0) || className.equals(Group.class.getName())) ||
267 (className.equals(Company.class.getName()) && staging)) {
268
269 className = Group.class.getName();
270 classNameId = groupClassNameId;
271 classPK = groupId;
272 }
273 else if (className.equals(Organization.class.getName())) {
274 name = getOrgGroupName(name);
275 }
276 else if (!GroupConstants.USER_PERSONAL_SITE.equals(name)) {
277 name = String.valueOf(classPK);
278 }
279
280 if (className.equals(Organization.class.getName()) && staging) {
281 classPK = liveGroupId;
282 }
283
284 if (className.equals(Layout.class.getName())) {
285 Layout layout = layoutLocalService.getLayout(classPK);
286
287 parentGroupId = layout.getGroupId();
288 }
289
290 friendlyURL = getFriendlyURL(
291 user.getCompanyId(), groupId, classNameId, classPK, friendlyName,
292 friendlyURL);
293
294 if (staging) {
295 name = name.concat(" (Staging)");
296 friendlyURL = friendlyURL.concat("-staging");
297 }
298
299 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
300 membershipRestriction =
301 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION;
302 }
303
304 if (className.equals(Group.class.getName())) {
305 if (!site && (liveGroupId == 0) &&
306 !name.equals(GroupConstants.CONTROL_PANEL)) {
307
308 throw new IllegalArgumentException();
309 }
310 }
311 else if (!className.equals(Company.class.getName()) &&
312 !className.equals(Organization.class.getName()) &&
313 className.startsWith("com.liferay.portal.model.")) {
314
315 if (site) {
316 throw new IllegalArgumentException();
317 }
318 }
319
320 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
321 validateName(groupId, user.getCompanyId(), name, site);
322 }
323
324 validateFriendlyURL(
325 user.getCompanyId(), groupId, classNameId, classPK, friendlyURL);
326
327 validateParentGroup(groupId, parentGroupId);
328
329 Group group = groupPersistence.create(groupId);
330
331 if (serviceContext != null) {
332 group.setUuid(serviceContext.getUuid());
333 }
334
335 group.setCompanyId(user.getCompanyId());
336 group.setCreatorUserId(userId);
337 group.setClassNameId(classNameId);
338 group.setClassPK(classPK);
339 group.setParentGroupId(parentGroupId);
340 group.setLiveGroupId(liveGroupId);
341 group.setTreePath(group.buildTreePath());
342 group.setName(name);
343 group.setDescription(description);
344 group.setType(type);
345 group.setManualMembership(manualMembership);
346 group.setMembershipRestriction(membershipRestriction);
347 group.setFriendlyURL(friendlyURL);
348 group.setSite(site);
349 group.setActive(active);
350
351 if ((serviceContext != null) && (classNameId == groupClassNameId) &&
352 !user.isDefaultUser()) {
353
354 group.setExpandoBridgeAttributes(serviceContext);
355 }
356
357 groupPersistence.update(group);
358
359
360
361 layoutSetLocalService.addLayoutSet(groupId, true);
362
363 layoutSetLocalService.addLayoutSet(groupId, false);
364
365 if ((classNameId == groupClassNameId) && !user.isDefaultUser()) {
366
367
368
369 resourceLocalService.addResources(
370 group.getCompanyId(), 0, 0, Group.class.getName(),
371 group.getGroupId(), false, false, false);
372
373
374
375 Role role = roleLocalService.getRole(
376 group.getCompanyId(), RoleConstants.SITE_OWNER);
377
378 userGroupRoleLocalService.addUserGroupRoles(
379 userId, groupId, new long[] {role.getRoleId()});
380
381
382
383 userLocalService.addGroupUsers(
384 group.getGroupId(), new long[] {userId});
385
386
387
388 if (serviceContext != null) {
389 updateAsset(
390 userId, group, serviceContext.getAssetCategoryIds(),
391 serviceContext.getAssetTagNames());
392 }
393 }
394 else if (className.equals(Organization.class.getName()) &&
395 !user.isDefaultUser()) {
396
397
398
399 resourceLocalService.addResources(
400 group.getCompanyId(), 0, 0, Group.class.getName(),
401 group.getGroupId(), false, false, false);
402 }
403
404 return group;
405 }
406
407
435 @Override
436 public Group addGroup(
437 long userId, long parentGroupId, String className, long classPK,
438 String name, String description, int type, String friendlyURL,
439 boolean site, boolean active, ServiceContext serviceContext)
440 throws PortalException, SystemException {
441
442 return addGroup(
443 userId, parentGroupId, className, classPK,
444 GroupConstants.DEFAULT_LIVE_GROUP_ID, name, description, type, true,
445 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
446 active, serviceContext);
447 }
448
449
478 @Override
479 public Group addGroup(
480 long userId, String className, long classPK, long liveGroupId,
481 String name, String description, int type, String friendlyURL,
482 boolean site, boolean active, ServiceContext serviceContext)
483 throws PortalException, SystemException {
484
485 return addGroup(
486 userId, GroupConstants.DEFAULT_PARENT_GROUP_ID, className, classPK,
487 liveGroupId, name, description, type, true,
488 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
489 active, serviceContext);
490 }
491
492
519 @Override
520 public Group addGroup(
521 long userId, String className, long classPK, String name,
522 String description, int type, String friendlyURL, boolean site,
523 boolean active, ServiceContext serviceContext)
524 throws PortalException, SystemException {
525
526 return addGroup(
527 userId, GroupConstants.DEFAULT_PARENT_GROUP_ID, className, classPK,
528 GroupConstants.DEFAULT_LIVE_GROUP_ID, name, description, type, true,
529 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
530 active, serviceContext);
531 }
532
533
540 @Override
541 public void addRoleGroups(long roleId, long[] groupIds)
542 throws SystemException {
543
544 rolePersistence.addGroups(roleId, groupIds);
545
546 PermissionCacheUtil.clearCache();
547 }
548
549
556 @Override
557 public void addUserGroups(long userId, long[] groupIds)
558 throws SystemException {
559
560 userPersistence.addGroups(userId, groupIds);
561
562 PermissionCacheUtil.clearCache();
563 }
564
565
576 @Override
577 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
578 public void checkCompanyGroup(long companyId)
579 throws PortalException, SystemException {
580
581 long classNameId = PortalUtil.getClassNameId(Company.class);
582
583 int count = groupPersistence.countByC_C_C(
584 companyId, classNameId, companyId);
585
586 if (count == 0) {
587 long defaultUserId = userLocalService.getDefaultUserId(companyId);
588
589 groupLocalService.addGroup(
590 defaultUserId, GroupConstants.DEFAULT_PARENT_GROUP_ID,
591 Company.class.getName(), companyId,
592 GroupConstants.DEFAULT_LIVE_GROUP_ID, GroupConstants.GLOBAL,
593 null, 0, true, GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION,
594 GroupConstants.GLOBAL_FRIENDLY_URL, true, true, null);
595 }
596 }
597
598
607 @Override
608 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
609 public void checkSystemGroups(long companyId)
610 throws PortalException, SystemException {
611
612 String companyIdHexString = StringUtil.toHexString(companyId);
613
614 for (Group group : groupFinder.findBySystem(companyId)) {
615 _systemGroupsMap.put(
616 companyIdHexString.concat(group.getName()), group);
617 }
618
619 long defaultUserId = userLocalService.getDefaultUserId(companyId);
620
621 String[] systemGroups = PortalUtil.getSystemGroups();
622
623 for (String name : systemGroups) {
624 String groupCacheKey = companyIdHexString.concat(name);
625
626 Group group = _systemGroupsMap.get(groupCacheKey);
627
628 if (group == null) {
629 group = groupPersistence.fetchByC_N(companyId, name);
630 }
631
632 if (group == null) {
633 String className = null;
634 long classPK = 0;
635 int type = GroupConstants.TYPE_SITE_OPEN;
636 String friendlyURL = null;
637 boolean site = true;
638
639 if (name.equals(GroupConstants.CONTROL_PANEL)) {
640 type = GroupConstants.TYPE_SITE_PRIVATE;
641 friendlyURL = GroupConstants.CONTROL_PANEL_FRIENDLY_URL;
642 site = false;
643 }
644 else if (name.equals(GroupConstants.GUEST)) {
645 friendlyURL = "/guest";
646 }
647 else if (name.equals(GroupConstants.USER_PERSONAL_SITE)) {
648 className = UserPersonalSite.class.getName();
649 classPK = defaultUserId;
650 type = GroupConstants.TYPE_SITE_PRIVATE;
651 friendlyURL =
652 GroupConstants.USER_PERSONAL_SITE_FRIENDLY_URL;
653 site = false;
654 }
655
656 group = groupLocalService.addGroup(
657 defaultUserId, GroupConstants.DEFAULT_PARENT_GROUP_ID,
658 className, classPK, GroupConstants.DEFAULT_LIVE_GROUP_ID,
659 name, null, type, true,
660 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL,
661 site, true, null);
662
663 if (name.equals(GroupConstants.USER_PERSONAL_SITE)) {
664 initUserPersonalSitePermissions(group);
665 }
666 }
667
668 if (group.isControlPanel()) {
669 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
670 group.getGroupId(), true);
671
672 if (layoutSet.getPageCount() == 0) {
673 addControlPanelLayouts(group);
674 }
675 }
676
677 if (group.getName().equals(GroupConstants.GUEST)) {
678 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
679 group.getGroupId(), false);
680
681 if (layoutSet.getPageCount() == 0) {
682 addDefaultGuestPublicLayouts(group);
683 }
684 }
685
686 _systemGroupsMap.put(groupCacheKey, group);
687 }
688 }
689
690
707 @Override
708 public Group deleteGroup(Group group)
709 throws PortalException, SystemException {
710
711 boolean deleteInProcess = GroupThreadLocal.isDeleteInProcess();
712
713 try {
714 GroupThreadLocal.setDeleteInProcess(true);
715
716 if (((group.isCompany() && !group.isCompanyStagingGroup()) ||
717 PortalUtil.isSystemGroup(group.getName())) &&
718 !CompanyThreadLocal.isDeleteInProcess()) {
719
720 throw new RequiredGroupException(
721 String.valueOf(group.getGroupId()),
722 RequiredGroupException.SYSTEM_GROUP);
723 }
724
725 if (groupPersistence.countByC_P_S(
726 group.getCompanyId(), group.getGroupId(), true) > 0) {
727
728 throw new RequiredGroupException(
729 String.valueOf(group.getGroupId()),
730 RequiredGroupException.PARENT_GROUP);
731 }
732
733 List<BackgroundTask> backgroundTasks =
734 backgroundTaskLocalService.getBackgroundTasks(
735 group.getGroupId(),
736 BackgroundTaskConstants.STATUS_IN_PROGRESS);
737
738 if (!backgroundTasks.isEmpty()) {
739 throw new PendingBackgroundTaskException(
740 "Unable to delete group with pending background tasks");
741 }
742
743
744
745 backgroundTaskLocalService.deleteGroupBackgroundTasks(
746 group.getGroupId());
747
748
749
750 layoutSetBranchLocalService.deleteLayoutSetBranches(
751 group.getGroupId(), true, true);
752
753 layoutSetBranchLocalService.deleteLayoutSetBranches(
754 group.getGroupId(), false, true);
755
756
757
758 ServiceContext serviceContext = new ServiceContext();
759
760 try {
761 layoutSetLocalService.deleteLayoutSet(
762 group.getGroupId(), true, serviceContext);
763 }
764 catch (NoSuchLayoutSetException nslse) {
765 }
766
767 try {
768 layoutSetLocalService.deleteLayoutSet(
769 group.getGroupId(), false, serviceContext);
770 }
771 catch (NoSuchLayoutSetException nslse) {
772 }
773
774
775
776 userGroupRoleLocalService.deleteUserGroupRolesByGroupId(
777 group.getGroupId());
778
779
780
781 userGroupGroupRoleLocalService.deleteUserGroupGroupRolesByGroupId(
782 group.getGroupId());
783
784
785
786 membershipRequestLocalService.deleteMembershipRequests(
787 group.getGroupId());
788
789
790
791 portletPreferencesLocalService.deletePortletPreferences(
792 group.getGroupId(), PortletKeys.PREFS_OWNER_TYPE_GROUP,
793 PortletKeys.PREFS_PLID_SHARED);
794
795
796
797 repositoryLocalService.deleteRepositories(group.getGroupId());
798
799
800
801 subscriptionLocalService.deleteSubscriptions(
802 group.getCompanyId(), BlogsEntry.class.getName(),
803 group.getGroupId());
804 subscriptionLocalService.deleteSubscriptions(
805 group.getCompanyId(), JournalArticle.class.getName(),
806 group.getGroupId());
807
808
809
810 teamLocalService.deleteTeams(group.getGroupId());
811
812
813
814 unscheduleStaging(group);
815
816 if (group.hasStagingGroup()) {
817 try {
818 StagingUtil.disableStaging(group, serviceContext);
819 }
820 catch (Exception e) {
821 _log.error(
822 "Unable to disable staging for group " +
823 group.getGroupId());
824 }
825 }
826
827
828
829 ThemeLoader themeLoader =
830 ThemeLoaderFactory.getDefaultThemeLoader();
831
832 if (themeLoader != null) {
833 String themePath =
834 themeLoader.getFileStorage() + StringPool.SLASH +
835 group.getGroupId();
836
837 FileUtil.deltree(themePath + "-private");
838 FileUtil.deltree(themePath + "-public");
839 }
840
841
842
843 deletePortletData(group);
844
845
846
847 if (group.isRegularSite()) {
848 assetEntryLocalService.deleteEntry(
849 Group.class.getName(), group.getGroupId());
850 }
851
852 assetTagLocalService.deleteGroupTags(group.getGroupId());
853
854 assetVocabularyLocalService.deleteVocabularies(group.getGroupId());
855
856
857
858 expandoRowLocalService.deleteRows(group.getGroupId());
859
860
861
862 shoppingCartLocalService.deleteGroupCarts(group.getGroupId());
863 shoppingCategoryLocalService.deleteCategories(group.getGroupId());
864 shoppingCouponLocalService.deleteCoupons(group.getGroupId());
865 shoppingOrderLocalService.deleteOrders(group.getGroupId());
866
867
868
869 socialActivityLocalService.deleteActivities(group.getGroupId());
870 socialActivitySettingLocalService.deleteActivitySettings(
871 group.getGroupId());
872
873
874
875 scFrameworkVersionLocalService.deleteFrameworkVersions(
876 group.getGroupId());
877 scProductEntryLocalService.deleteProductEntries(group.getGroupId());
878
879
880
881 List<ResourcePermission> resourcePermissions =
882 resourcePermissionPersistence.findByC_LikeP(
883 group.getCompanyId(), String.valueOf(group.getGroupId()));
884
885 for (ResourcePermission resourcePermission : resourcePermissions) {
886 resourcePermissionLocalService.deleteResourcePermission(
887 resourcePermission);
888 }
889
890 if (!group.isStagingGroup() &&
891 (group.isOrganization() || group.isRegularSite())) {
892
893 resourceLocalService.deleteResource(
894 group.getCompanyId(), Group.class.getName(),
895 ResourceConstants.SCOPE_INDIVIDUAL, group.getGroupId());
896 }
897
898
899
900 List<WorkflowHandler> scopeableWorkflowHandlers =
901 WorkflowHandlerRegistryUtil.getScopeableWorkflowHandlers();
902
903 for (WorkflowHandler scopeableWorkflowHandler :
904 scopeableWorkflowHandlers) {
905
906 if (!scopeableWorkflowHandler.isVisible()) {
907 continue;
908 }
909
910 WorkflowDefinitionLink workflowDefinitionLink =
911 workflowDefinitionLinkLocalService.
912 fetchWorkflowDefinitionLink(
913 group.getCompanyId(), group.getGroupId(),
914 scopeableWorkflowHandler.getClassName(), 0, 0,
915 true);
916
917 if (workflowDefinitionLink == null) {
918 continue;
919 }
920
921 workflowDefinitionLinkLocalService.deleteWorkflowDefinitionLink(
922 workflowDefinitionLink);
923 }
924
925
926
927 if (!group.isStagingGroup() && group.isOrganization() &&
928 group.isSite()) {
929
930 group.setSite(false);
931
932 groupPersistence.update(group);
933 }
934 else {
935 groupPersistence.remove(group);
936 }
937
938
939
940 PermissionCacheUtil.clearCache();
941
942 return group;
943 }
944 finally {
945 GroupThreadLocal.setDeleteInProcess(deleteInProcess);
946 }
947 }
948
949
966 @Override
967 public Group deleteGroup(long groupId)
968 throws PortalException, SystemException {
969
970 Group group = groupPersistence.findByPrimaryKey(groupId);
971
972 return deleteGroup(group);
973 }
974
975 @Override
976 public synchronized void disableStaging(long groupId)
977 throws PortalException, SystemException {
978
979 Group group = groupPersistence.findByPrimaryKey(groupId);
980
981 int stagingGroupCount = group.getRemoteStagingGroupCount();
982
983 if (stagingGroupCount > 0) {
984 stagingGroupCount = stagingGroupCount - 1;
985
986 group.setRemoteStagingGroupCount(stagingGroupCount);
987
988 if (stagingGroupCount == 0) {
989 UnicodeProperties typeSettingsProperties =
990 group.getTypeSettingsProperties();
991
992 List<String> keys = new ArrayList<String>();
993
994 for (String key : typeSettingsProperties.keySet()) {
995 if (key.startsWith(StagingConstants.STAGED_PORTLET)) {
996 keys.add(key);
997 }
998 }
999
1000 for (String key : keys) {
1001 typeSettingsProperties.remove(key);
1002 }
1003
1004 group.setTypeSettingsProperties(typeSettingsProperties);
1005 }
1006
1007 groupPersistence.update(group);
1008 }
1009 }
1010
1011 @Override
1012 public synchronized void enableStaging(long groupId)
1013 throws PortalException, SystemException {
1014
1015 Group group = groupPersistence.findByPrimaryKey(groupId);
1016
1017 int stagingGroupCount = group.getRemoteStagingGroupCount() + 1;
1018
1019 group.setRemoteStagingGroupCount(stagingGroupCount);
1020
1021 groupPersistence.update(group);
1022 }
1023
1024
1033 @Override
1034 public Group fetchFriendlyURLGroup(long companyId, String friendlyURL)
1035 throws SystemException {
1036
1037 if (Validator.isNull(friendlyURL)) {
1038 return null;
1039 }
1040
1041 friendlyURL = getFriendlyURL(friendlyURL);
1042
1043 return groupPersistence.fetchByC_F(companyId, friendlyURL);
1044 }
1045
1046
1056 @Override
1057 @Skip
1058 public Group fetchGroup(long companyId, String name)
1059 throws SystemException {
1060
1061 Group group = _systemGroupsMap.get(
1062 StringUtil.toHexString(companyId).concat(name));
1063
1064 if (group != null) {
1065 return group;
1066 }
1067
1068 return groupLocalService.loadFetchGroup(companyId, name);
1069 }
1070
1071
1079 @Override
1080 public Group getCompanyGroup(long companyId)
1081 throws PortalException, SystemException {
1082
1083 long classNameId = PortalUtil.getClassNameId(Company.class);
1084
1085 return groupPersistence.findByC_C_C(companyId, classNameId, companyId);
1086 }
1087
1088
1108 @Override
1109 public List<Group> getCompanyGroups(long companyId, int start, int end)
1110 throws SystemException {
1111
1112 return groupPersistence.findByCompanyId(companyId, start, end);
1113 }
1114
1115
1122 @Override
1123 public int getCompanyGroupsCount(long companyId) throws SystemException {
1124 return groupPersistence.countByCompanyId(companyId);
1125 }
1126
1127
1137 @Override
1138 public Group getFriendlyURLGroup(long companyId, String friendlyURL)
1139 throws PortalException, SystemException {
1140
1141 if (Validator.isNull(friendlyURL)) {
1142 throw new NoSuchGroupException();
1143 }
1144
1145 friendlyURL = getFriendlyURL(friendlyURL);
1146
1147 return groupPersistence.findByC_F(companyId, friendlyURL);
1148 }
1149
1150
1159 @Override
1160 @ThreadLocalCachable
1161 public Group getGroup(long groupId)
1162 throws PortalException, SystemException {
1163
1164 return groupPersistence.findByPrimaryKey(groupId);
1165 }
1166
1167
1176 @Override
1177 @Skip
1178 public Group getGroup(long companyId, String name)
1179 throws PortalException, SystemException {
1180
1181 Group group = _systemGroupsMap.get(
1182 StringUtil.toHexString(companyId).concat(name));
1183
1184 if (group != null) {
1185 return group;
1186 }
1187
1188 return groupLocalService.loadGetGroup(companyId, name);
1189 }
1190
1191 @Override
1192 public String getGroupDescriptiveName(Group group, Locale locale)
1193 throws PortalException, SystemException {
1194
1195 String name = group.getName();
1196
1197 if (group.isCompany() && !group.isCompanyStagingGroup()) {
1198 name = LanguageUtil.get(locale, "global");
1199 }
1200 else if (group.isControlPanel()) {
1201 name = LanguageUtil.get(locale, "control-panel");
1202 }
1203 else if (group.isLayout()) {
1204 Layout layout = layoutLocalService.getLayout(group.getClassPK());
1205
1206 name = layout.getName(locale);
1207 }
1208 else if (group.isLayoutPrototype()) {
1209 LayoutPrototype layoutPrototype =
1210 layoutPrototypeLocalService.getLayoutPrototype(
1211 group.getClassPK());
1212
1213 name = layoutPrototype.getName(locale);
1214 }
1215 else if (group.isLayoutSetPrototype()) {
1216 LayoutSetPrototype layoutSetPrototype =
1217 layoutSetPrototypePersistence.findByPrimaryKey(
1218 group.getClassPK());
1219
1220 name = layoutSetPrototype.getName(locale);
1221 }
1222 else if (group.isOrganization()) {
1223 long organizationId = group.getOrganizationId();
1224
1225 Organization organization =
1226 organizationPersistence.findByPrimaryKey(organizationId);
1227
1228 name = organization.getName();
1229
1230 Group organizationGroup = organization.getGroup();
1231
1232 if (organizationGroup.isStaged() && group.isStagingGroup()) {
1233 name = name + " (" + LanguageUtil.get(locale, "staging") + ")";
1234 }
1235 }
1236 else if (group.isUser()) {
1237 long userId = group.getClassPK();
1238
1239 User user = userPersistence.findByPrimaryKey(userId);
1240
1241 name = user.getFullName();
1242 }
1243 else if (group.isUserGroup()) {
1244 long userGroupId = group.getClassPK();
1245
1246 UserGroup userGroup = userGroupPersistence.findByPrimaryKey(
1247 userGroupId);
1248
1249 name = userGroup.getName();
1250 }
1251 else if (group.isUserPersonalSite()) {
1252 name = LanguageUtil.get(locale, "user-personal-site");
1253 }
1254 else if (name.equals(GroupConstants.GUEST)) {
1255 Company company = companyPersistence.findByPrimaryKey(
1256 group.getCompanyId());
1257
1258 Account account = company.getAccount();
1259
1260 name = account.getName();
1261 }
1262
1263 return name;
1264 }
1265
1266 @Override
1267 public String getGroupDescriptiveName(long groupId, Locale locale)
1268 throws PortalException, SystemException {
1269
1270 Group group = groupPersistence.findByPrimaryKey(groupId);
1271
1272 return getGroupDescriptiveName(group, locale);
1273 }
1274
1275
1285 @Override
1286 public List<Group> getGroups(
1287 long companyId, long parentGroupId, boolean site)
1288 throws SystemException {
1289
1290 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
1291 return groupPersistence.findByC_S(companyId, site);
1292 }
1293
1294 return groupPersistence.findByC_P_S(companyId, parentGroupId, site);
1295 }
1296
1297
1308 @Override
1309 public List<Group> getGroups(
1310 long companyId, String className, long parentGroupId)
1311 throws SystemException {
1312
1313 long classNameId = PortalUtil.getClassNameId(className);
1314
1315 return groupPersistence.findByC_C_P(
1316 companyId, classNameId, parentGroupId);
1317 }
1318
1319
1331 @Override
1332 public List<Group> getGroups(
1333 long companyId, String className, long parentGroupId, int start,
1334 int end)
1335 throws SystemException {
1336
1337 long classNameId = PortalUtil.getClassNameId(className);
1338
1339 return groupPersistence.findByC_C_P(
1340 companyId, classNameId, parentGroupId, start, end);
1341 }
1342
1343
1351 @Override
1352 public List<Group> getGroups(long[] groupIds)
1353 throws PortalException, SystemException {
1354
1355 List<Group> groups = new ArrayList<Group>(groupIds.length);
1356
1357 for (long groupId : groupIds) {
1358 Group group = getGroup(groupId);
1359
1360 groups.add(group);
1361 }
1362
1363 return groups;
1364 }
1365
1366
1376 @Override
1377 public int getGroupsCount(long companyId, long parentGroupId, boolean site)
1378 throws SystemException {
1379
1380 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
1381 return groupPersistence.countByC_S(companyId, site);
1382 }
1383
1384 return groupPersistence.countByC_P_S(companyId, parentGroupId, site);
1385 }
1386
1387
1397 @Override
1398 public int getGroupsCount(
1399 long companyId, String className, long parentGroupId)
1400 throws SystemException {
1401
1402 long classNameId = PortalUtil.getClassNameId(className);
1403
1404 return groupPersistence.countByC_C_P(
1405 companyId, classNameId, parentGroupId);
1406 }
1407
1408
1417 @Override
1418 public Group getLayoutGroup(long companyId, long plid)
1419 throws PortalException, SystemException {
1420
1421 long classNameId = PortalUtil.getClassNameId(Layout.class);
1422
1423 return groupPersistence.findByC_C_C(companyId, classNameId, plid);
1424 }
1425
1426
1435 @Override
1436 public Group getLayoutPrototypeGroup(long companyId, long layoutPrototypeId)
1437 throws PortalException, SystemException {
1438
1439 long classNameId = PortalUtil.getClassNameId(LayoutPrototype.class);
1440
1441 return groupPersistence.findByC_C_C(
1442 companyId, classNameId, layoutPrototypeId);
1443 }
1444
1445
1454 @Override
1455 public Group getLayoutSetPrototypeGroup(
1456 long companyId, long layoutSetPrototypeId)
1457 throws PortalException, SystemException {
1458
1459 long classNameId = PortalUtil.getClassNameId(LayoutSetPrototype.class);
1460
1461 return groupPersistence.findByC_C_C(
1462 companyId, classNameId, layoutSetPrototypeId);
1463 }
1464
1465
1488 @Override
1489 public List<Group> getLayoutsGroups(
1490 long companyId, long parentGroupId, boolean site, int start,
1491 int end)
1492 throws SystemException {
1493
1494 return groupFinder.findByLayouts(
1495 companyId, parentGroupId, site, start, end);
1496 }
1497
1498
1508 @Override
1509 public int getLayoutsGroupsCount(
1510 long companyId, long parentGroupId, boolean site)
1511 throws SystemException {
1512
1513 return groupFinder.countByLayouts(companyId, parentGroupId, site);
1514 }
1515
1516
1522 @Override
1523 public List<Group> getLiveGroups() throws SystemException {
1524 return groupFinder.findByLiveGroups();
1525 }
1526
1527
1550 @Override
1551 public List<Group> getNoLayoutsGroups(
1552 String className, boolean privateLayout, int start, int end)
1553 throws SystemException {
1554
1555 long classNameId = PortalUtil.getClassNameId(className);
1556
1557 return groupFinder.findByNoLayouts(
1558 classNameId, privateLayout, start, end);
1559 }
1560
1561
1569 @Override
1570 public List<Group> getNullFriendlyURLGroups() throws SystemException {
1571 return groupFinder.findByNullFriendlyURL();
1572 }
1573
1574
1583 @Override
1584 public Group getOrganizationGroup(long companyId, long organizationId)
1585 throws PortalException, SystemException {
1586
1587 long classNameId = PortalUtil.getClassNameId(Organization.class);
1588
1589 return groupPersistence.findByC_C_C(
1590 companyId, classNameId, organizationId);
1591 }
1592
1593
1599 @Override
1600 public List<Group> getOrganizationsGroups(
1601 List<Organization> organizations) {
1602
1603 List<Group> organizationGroups = new ArrayList<Group>();
1604
1605 for (int i = 0; i < organizations.size(); i++) {
1606 Organization organization = organizations.get(i);
1607
1608 Group group = organization.getGroup();
1609
1610 organizationGroups.add(group);
1611 }
1612
1613 return organizationGroups;
1614 }
1615
1616
1623 @Override
1624 public List<Group> getOrganizationsRelatedGroups(
1625 List<Organization> organizations)
1626 throws SystemException {
1627
1628 List<Group> organizationGroups = new ArrayList<Group>();
1629
1630 for (int i = 0; i < organizations.size(); i++) {
1631 Organization organization = organizations.get(i);
1632
1633 List<Group> groups = organizationPersistence.getGroups(
1634 organization.getOrganizationId());
1635
1636 organizationGroups.addAll(groups);
1637 }
1638
1639 return organizationGroups;
1640 }
1641
1642
1653 @Override
1654 public List<Group> getParentGroups(long groupId)
1655 throws PortalException, SystemException {
1656
1657 if (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
1658 return new ArrayList<Group>();
1659 }
1660
1661 Group group = groupPersistence.findByPrimaryKey(groupId);
1662
1663 return group.getAncestors();
1664 }
1665
1666
1674 @Override
1675 public Group getStagingGroup(long liveGroupId)
1676 throws PortalException, SystemException {
1677
1678 return groupPersistence.findByLiveGroupId(liveGroupId);
1679 }
1680
1681
1690 @Override
1691 public Group getUserGroup(long companyId, long userId)
1692 throws PortalException, SystemException {
1693
1694 long classNameId = PortalUtil.getClassNameId(User.class);
1695
1696 return groupPersistence.findByC_C_C(companyId, classNameId, userId);
1697 }
1698
1699
1709 @Override
1710 public Group getUserGroupGroup(long companyId, long userGroupId)
1711 throws PortalException, SystemException {
1712
1713 long classNameId = PortalUtil.getClassNameId(UserGroup.class);
1714
1715 return groupPersistence.findByC_C_C(
1716 companyId, classNameId, userGroupId);
1717 }
1718
1719
1731 @Override
1732 public List<Group> getUserGroups(long userId, boolean inherit)
1733 throws PortalException, SystemException {
1734
1735 return getUserGroups(
1736 userId, inherit, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1737 }
1738
1739
1766 @Override
1767 public List<Group> getUserGroups(
1768 long userId, boolean inherit, int start, int end)
1769 throws PortalException, SystemException {
1770
1771 if (inherit) {
1772 User user = userPersistence.findByPrimaryKey(userId);
1773
1774 LinkedHashMap<String, Object> groupParams =
1775 new LinkedHashMap<String, Object>();
1776
1777 groupParams.put("usersGroups", new Long(userId));
1778
1779 return search(
1780 user.getCompanyId(), null, null, groupParams, start, end);
1781 }
1782 else {
1783 return userPersistence.getGroups(userId, start, end);
1784 }
1785 }
1786
1787
1796 @Override
1797 public List<Group> getUserGroupsGroups(List<UserGroup> userGroups)
1798 throws PortalException, SystemException {
1799
1800 List<Group> userGroupGroups = new ArrayList<Group>();
1801
1802 for (int i = 0; i < userGroups.size(); i++) {
1803 UserGroup userGroup = userGroups.get(i);
1804
1805 Group group = userGroup.getGroup();
1806
1807 userGroupGroups.add(group);
1808 }
1809
1810 return userGroupGroups;
1811 }
1812
1813
1820 @Override
1821 public List<Group> getUserGroupsRelatedGroups(List<UserGroup> userGroups)
1822 throws SystemException {
1823
1824 List<Group> userGroupGroups = new ArrayList<Group>();
1825
1826 for (int i = 0; i < userGroups.size(); i++) {
1827 UserGroup userGroup = userGroups.get(i);
1828
1829 List<Group> groups = userGroupPersistence.getGroups(
1830 userGroup.getUserGroupId());
1831
1832 userGroupGroups.addAll(groups);
1833 }
1834
1835 return userGroupGroups;
1836 }
1837
1838
1864 @Override
1865 public List<Group> getUserOrganizationsGroups(
1866 long userId, int start, int end)
1867 throws PortalException, SystemException {
1868
1869 List<Group> userOrgsGroups = new UniqueList<Group>();
1870
1871 List<Organization> userOrgs =
1872 organizationLocalService.getUserOrganizations(userId, start, end);
1873
1874 for (Organization organization : userOrgs) {
1875 userOrgsGroups.add(0, organization.getGroup());
1876
1877 if (!PropsValues.ORGANIZATIONS_MEMBERSHIP_STRICT) {
1878 for (Organization ancestorOrganization :
1879 organization.getAncestors()) {
1880
1881 userOrgsGroups.add(0, ancestorOrganization.getGroup());
1882 }
1883 }
1884 }
1885
1886 return userOrgsGroups;
1887 }
1888
1889 @Override
1890 public Group getUserPersonalSiteGroup(long companyId)
1891 throws PortalException, SystemException {
1892
1893 long classNameId = PortalUtil.getClassNameId(UserPersonalSite.class);
1894 long defaultUserId = userLocalService.getDefaultUserId(companyId);
1895
1896 return groupPersistence.findByC_C_C(
1897 companyId, classNameId, defaultUserId);
1898 }
1899
1900 @Override
1901 public List<Group> getUserSitesGroups(long userId)
1902 throws PortalException, SystemException {
1903
1904 User user = userPersistence.findByPrimaryKey(userId);
1905
1906 LinkedHashMap<String, Object> groupParams =
1907 new LinkedHashMap<String, Object>();
1908
1909 groupParams.put("inherit", Boolean.TRUE);
1910 groupParams.put("site", Boolean.TRUE);
1911 groupParams.put("usersGroups", userId);
1912
1913 return groupFinder.findByCompanyId(
1914 user.getCompanyId(), groupParams, QueryUtil.ALL_POS,
1915 QueryUtil.ALL_POS, new GroupNameComparator(true));
1916 }
1917
1918 @Override
1919 public List<Group> getUserSitesGroups(
1920 long userId, boolean includeAdministrative)
1921 throws PortalException, SystemException {
1922
1923 if (!includeAdministrative) {
1924 return getUserSitesGroups(userId);
1925 }
1926
1927 Set<Group> sites = new HashSet<Group>();
1928
1929 List<UserGroupRole> userGroupRoles =
1930 userGroupRoleLocalService.getUserGroupRoles(userId);
1931
1932 for (UserGroupRole userGroupRole : userGroupRoles) {
1933 Role role = userGroupRole.getRole();
1934
1935 String roleName = role.getName();
1936
1937 if (roleName.equals(RoleConstants.SITE_ADMINISTRATOR) ||
1938 roleName.equals(RoleConstants.SITE_OWNER)) {
1939
1940 Group group = userGroupRole.getGroup();
1941
1942 sites.add(group);
1943 }
1944 }
1945
1946 sites.addAll(getUserSitesGroups(userId));
1947
1948 return new ArrayList<Group>(sites);
1949 }
1950
1951
1959 @Override
1960 public boolean hasStagingGroup(long liveGroupId) throws SystemException {
1961 if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
1962 return true;
1963 }
1964 else {
1965 return false;
1966 }
1967 }
1968
1969
1980 @Override
1981 public boolean hasUserGroup(long userId, long groupId)
1982 throws SystemException {
1983
1984 return hasUserGroup(userId, groupId, true);
1985 }
1986
1987
2000 @Override
2001 public boolean hasUserGroup(long userId, long groupId, boolean inherit)
2002 throws SystemException {
2003
2004 if (groupFinder.countByG_U(groupId, userId, inherit) > 0) {
2005 return true;
2006 }
2007 else {
2008 return false;
2009 }
2010 }
2011
2012
2022 @Override
2023 public Group loadFetchGroup(long companyId, String name)
2024 throws SystemException {
2025
2026 return groupPersistence.fetchByC_N(companyId, name);
2027 }
2028
2029
2038 @Override
2039 public Group loadGetGroup(long companyId, String name)
2040 throws PortalException, SystemException {
2041
2042 return groupPersistence.findByC_N(companyId, name);
2043 }
2044
2045
2059 @Override
2060 public void rebuildTree(long companyId)
2061 throws PortalException, SystemException {
2062
2063 List<Group> groups = groupPersistence.findByCompanyId(companyId);
2064
2065 for (Group group : groups) {
2066 group.setTreePath(group.buildTreePath());
2067
2068 groupPersistence.update(group);
2069 }
2070 }
2071
2072
2101 @Override
2102 public List<Group> search(
2103 long companyId, LinkedHashMap<String, Object> params, int start,
2104 int end)
2105 throws SystemException {
2106
2107 return groupFinder.findByCompanyId(
2108 companyId, params, start, end, new GroupNameComparator(true));
2109 }
2110
2111
2143 @Override
2144 public List<Group> search(
2145 long companyId, long parentGroupId, String keywords,
2146 LinkedHashMap<String, Object> params, int start, int end)
2147 throws SystemException {
2148
2149 return search(
2150 companyId, getClassNameIds(), parentGroupId, keywords, params,
2151 start, end, null);
2152 }
2153
2154
2188 @Override
2189 public List<Group> search(
2190 long companyId, long parentGroupId, String keywords,
2191 LinkedHashMap<String, Object> params, int start, int end,
2192 OrderByComparator obc)
2193 throws SystemException {
2194
2195 return search(
2196 companyId, getClassNameIds(), parentGroupId, keywords, params,
2197 start, end, obc);
2198 }
2199
2200
2235 @Override
2236 public List<Group> search(
2237 long companyId, long parentGroupId, String name, String description,
2238 LinkedHashMap<String, Object> params, boolean andOperator,
2239 int start, int end)
2240 throws SystemException {
2241
2242 return search(
2243 companyId, getClassNameIds(), parentGroupId, name, description,
2244 params, andOperator, start, end, null);
2245 }
2246
2247
2284 @Override
2285 public List<Group> search(
2286 long companyId, long parentGroupId, String name, String description,
2287 LinkedHashMap<String, Object> params, boolean andOperator,
2288 int start, int end, OrderByComparator obc)
2289 throws SystemException {
2290
2291 return search(
2292 companyId, getClassNameIds(), parentGroupId, name, description,
2293 params, andOperator, start, end, obc);
2294 }
2295
2296
2331 @Override
2332 public List<Group> search(
2333 long companyId, long[] classNameIds, long parentGroupId,
2334 String keywords, LinkedHashMap<String, Object> params, int start,
2335 int end)
2336 throws SystemException {
2337
2338 return search(
2339 companyId, classNameIds, parentGroupId, keywords, params, start,
2340 end, null);
2341 }
2342
2343
2380 @Override
2381 public List<Group> search(
2382 long companyId, long[] classNameIds, long parentGroupId,
2383 String keywords, LinkedHashMap<String, Object> params, int start,
2384 int end, OrderByComparator obc)
2385 throws SystemException {
2386
2387 String[] keywordsArray = getSearchNames(companyId, keywords);
2388
2389 boolean andOperator = false;
2390
2391 if (Validator.isNull(keywords)) {
2392 andOperator = true;
2393 }
2394
2395 if (isUseComplexSQL(classNameIds)) {
2396 return groupFinder.findByC_C_PG_N_D(
2397 companyId, classNameIds, parentGroupId, keywordsArray,
2398 keywordsArray, params, andOperator, start, end, obc);
2399 }
2400
2401 List<Group> groups = doSearch(
2402 companyId, classNameIds, parentGroupId, keywordsArray,
2403 keywordsArray, params, andOperator);
2404
2405 return sort(groups, start, end, obc);
2406 }
2407
2408
2446 @Override
2447 public List<Group> search(
2448 long companyId, long[] classNameIds, long parentGroupId,
2449 String name, String description,
2450 LinkedHashMap<String, Object> params, boolean andOperator,
2451 int start, int end)
2452 throws SystemException {
2453
2454 return search(
2455 companyId, classNameIds, parentGroupId, name, description, params,
2456 andOperator, start, end, null);
2457 }
2458
2459
2499 @Override
2500 public List<Group> search(
2501 long companyId, long[] classNameIds, long parentGroupId,
2502 String name, String description,
2503 LinkedHashMap<String, Object> params, boolean andOperator,
2504 int start, int end, OrderByComparator obc)
2505 throws SystemException {
2506
2507 String[] names = getSearchNames(companyId, name);
2508 String[] descriptions = CustomSQLUtil.keywords(description);
2509
2510 if (isUseComplexSQL(classNameIds)) {
2511 return groupFinder.findByC_C_PG_N_D(
2512 companyId, classNameIds, parentGroupId, names, descriptions,
2513 params, andOperator, start, end, obc);
2514 }
2515
2516 List<Group> groups = doSearch(
2517 companyId, classNameIds, parentGroupId, names, descriptions, params,
2518 andOperator);
2519
2520 return sort(groups, start, end, obc);
2521 }
2522
2523
2556 @Override
2557 public List<Group> search(
2558 long companyId, long[] classNameIds, String keywords,
2559 LinkedHashMap<String, Object> params, int start, int end)
2560 throws SystemException {
2561
2562 return search(
2563 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
2564 keywords, params, start, end, null);
2565 }
2566
2567
2602 @Override
2603 public List<Group> search(
2604 long companyId, long[] classNameIds, String keywords,
2605 LinkedHashMap<String, Object> params, int start, int end,
2606 OrderByComparator obc)
2607 throws SystemException {
2608
2609 return search(
2610 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
2611 keywords, params, start, end, obc);
2612 }
2613
2614
2651 @Override
2652 public List<Group> search(
2653 long companyId, long[] classNameIds, String name,
2654 String description, LinkedHashMap<String, Object> params,
2655 boolean andOperator, int start, int end)
2656 throws SystemException {
2657
2658 return search(
2659 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
2660 description, params, andOperator, start, end, null);
2661 }
2662
2663
2702 @Override
2703 public List<Group> search(
2704 long companyId, long[] classNameIds, String name,
2705 String description, LinkedHashMap<String, Object> params,
2706 boolean andOperator, int start, int end, OrderByComparator obc)
2707 throws SystemException {
2708
2709 return search(
2710 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
2711 description, params, andOperator, start, end, obc);
2712 }
2713
2714
2744 @Override
2745 @ThreadLocalCachable
2746 public List<Group> search(
2747 long companyId, String keywords,
2748 LinkedHashMap<String, Object> params, int start, int end)
2749 throws SystemException {
2750
2751 return search(
2752 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2753 keywords, params, start, end, null);
2754 }
2755
2756
2788 @Override
2789 public List<Group> search(
2790 long companyId, String keywords,
2791 LinkedHashMap<String, Object> params, int start, int end,
2792 OrderByComparator obc)
2793 throws SystemException {
2794
2795 return search(
2796 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2797 keywords, params, start, end, obc);
2798 }
2799
2800
2834 @Override
2835 public List<Group> search(
2836 long companyId, String name, String description,
2837 LinkedHashMap<String, Object> params, boolean andOperator,
2838 int start, int end)
2839 throws SystemException {
2840
2841 return search(
2842 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2843 name, description, params, andOperator, start, end, null);
2844 }
2845
2846
2882 @Override
2883 public List<Group> search(
2884 long companyId, String name, String description,
2885 LinkedHashMap<String, Object> params, boolean andOperator,
2886 int start, int end, OrderByComparator obc)
2887 throws SystemException {
2888
2889 return search(
2890 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2891 name, description, params, andOperator, start, end, obc);
2892 }
2893
2894
2912 @Override
2913 @ThreadLocalCachable
2914 public int searchCount(
2915 long companyId, long parentGroupId, String keywords,
2916 LinkedHashMap<String, Object> params)
2917 throws SystemException {
2918
2919 return searchCount(
2920 companyId, getClassNameIds(), parentGroupId, keywords, params);
2921 }
2922
2923
2945 @Override
2946 @ThreadLocalCachable
2947 public int searchCount(
2948 long companyId, long parentGroupId, String name, String description,
2949 LinkedHashMap<String, Object> params, boolean andOperator)
2950 throws SystemException {
2951
2952 return searchCount(
2953 companyId, getClassNameIds(), parentGroupId, name, description,
2954 params, andOperator);
2955 }
2956
2957
2978 @Override
2979 @ThreadLocalCachable
2980 public int searchCount(
2981 long companyId, long[] classNameIds, long parentGroupId,
2982 String keywords, LinkedHashMap<String, Object> params)
2983 throws SystemException {
2984
2985 String[] keywordsArray = getSearchNames(companyId, keywords);
2986
2987 boolean andOperator = false;
2988
2989 if (Validator.isNull(keywords)) {
2990 andOperator = true;
2991 }
2992
2993 if (isUseComplexSQL(classNameIds)) {
2994 return groupFinder.countByC_C_PG_N_D(
2995 companyId, classNameIds, parentGroupId, keywordsArray,
2996 keywordsArray, params, andOperator);
2997 }
2998
2999 List<Group> groups = doSearch(
3000 companyId, classNameIds, parentGroupId, keywordsArray,
3001 keywordsArray, params, andOperator);
3002
3003 return groups.size();
3004 }
3005
3006
3030 @Override
3031 @ThreadLocalCachable
3032 public int searchCount(
3033 long companyId, long[] classNameIds, long parentGroupId,
3034 String name, String description,
3035 LinkedHashMap<String, Object> params, boolean andOperator)
3036 throws SystemException {
3037
3038 String[] names = getSearchNames(companyId, name);
3039 String[] descriptions = CustomSQLUtil.keywords(description);
3040
3041 if (isUseComplexSQL(classNameIds)) {
3042 return groupFinder.countByC_C_PG_N_D(
3043 companyId, classNameIds, parentGroupId, names, descriptions,
3044 params, andOperator);
3045 }
3046
3047 List<Group> groups = doSearch(
3048 companyId, classNameIds, parentGroupId, names, descriptions, params,
3049 andOperator);
3050
3051 return groups.size();
3052 }
3053
3054
3073 @Override
3074 @ThreadLocalCachable
3075 public int searchCount(
3076 long companyId, long[] classNameIds, String keywords,
3077 LinkedHashMap<String, Object> params)
3078 throws SystemException {
3079
3080 return searchCount(
3081 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
3082 keywords, params);
3083 }
3084
3085
3107 @Override
3108 @ThreadLocalCachable
3109 public int searchCount(
3110 long companyId, long[] classNameIds, String name,
3111 String description, LinkedHashMap<String, Object> params,
3112 boolean andOperator)
3113 throws SystemException {
3114
3115 return searchCount(
3116 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
3117 description, params, andOperator);
3118 }
3119
3120
3137 @Override
3138 @ThreadLocalCachable
3139 public int searchCount(
3140 long companyId, String keywords,
3141 LinkedHashMap<String, Object> params)
3142 throws SystemException {
3143
3144 return searchCount(
3145 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
3146 keywords, params);
3147 }
3148
3149
3170 @Override
3171 @ThreadLocalCachable
3172 public int searchCount(
3173 long companyId, String name, String description,
3174 LinkedHashMap<String, Object> params, boolean andOperator)
3175 throws SystemException {
3176
3177 return searchCount(
3178 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
3179 name, description, params, andOperator);
3180 }
3181
3182
3190 @Override
3191 public void setRoleGroups(long roleId, long[] groupIds)
3192 throws SystemException {
3193
3194 rolePersistence.setGroups(roleId, groupIds);
3195
3196 PermissionCacheUtil.clearCache();
3197 }
3198
3199
3206 @Override
3207 public void unsetRoleGroups(long roleId, long[] groupIds)
3208 throws SystemException {
3209
3210 rolePersistence.removeGroups(roleId, groupIds);
3211
3212 PermissionCacheUtil.clearCache();
3213 }
3214
3215
3222 @Override
3223 public void unsetUserGroups(long userId, long[] groupIds)
3224 throws SystemException {
3225
3226 userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
3227
3228 userPersistence.removeGroups(userId, groupIds);
3229
3230 PermissionCacheUtil.clearCache();
3231 }
3232
3233
3244 @Override
3245 public void updateAsset(
3246 long userId, Group group, long[] assetCategoryIds,
3247 String[] assetTagNames)
3248 throws PortalException, SystemException {
3249
3250 User user = userPersistence.findByPrimaryKey(userId);
3251
3252 Company company = companyPersistence.findByPrimaryKey(
3253 user.getCompanyId());
3254
3255 Group companyGroup = company.getGroup();
3256
3257 assetEntryLocalService.updateEntry(
3258 userId, companyGroup.getGroupId(), null, null,
3259 Group.class.getName(), group.getGroupId(), null, 0,
3260 assetCategoryIds, assetTagNames, false, null, null, null, null,
3261 group.getDescriptiveName(), group.getDescription(), null, null,
3262 null, 0, 0, null, false);
3263 }
3264
3265
3277 @Override
3278 public Group updateFriendlyURL(long groupId, String friendlyURL)
3279 throws PortalException, SystemException {
3280
3281 Group group = groupPersistence.findByPrimaryKey(groupId);
3282
3283 if (group.isUser()) {
3284 User user = userPersistence.findByPrimaryKey(group.getClassPK());
3285
3286 friendlyURL = StringPool.SLASH + user.getScreenName();
3287
3288 if (group.getFriendlyURL().equals(friendlyURL)) {
3289 return group;
3290 }
3291 }
3292
3293 friendlyURL = getFriendlyURL(
3294 group.getCompanyId(), groupId, group.getClassNameId(),
3295 group.getClassPK(), StringPool.BLANK, friendlyURL);
3296
3297 validateFriendlyURL(
3298 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
3299 group.getClassPK(), friendlyURL);
3300
3301 group.setFriendlyURL(friendlyURL);
3302
3303 groupPersistence.update(group);
3304
3305 return group;
3306 }
3307
3308
3330 @Override
3331 public Group updateGroup(
3332 long groupId, long parentGroupId, String name, String description,
3333 int type, boolean manualMembership, int membershipRestriction,
3334 String friendlyURL, boolean active, ServiceContext serviceContext)
3335 throws PortalException, SystemException {
3336
3337 Group group = groupPersistence.findByPrimaryKey(groupId);
3338
3339 String className = group.getClassName();
3340 long classNameId = group.getClassNameId();
3341 long classPK = group.getClassPK();
3342 friendlyURL = getFriendlyURL(
3343 group.getCompanyId(), groupId, classNameId, classPK,
3344 StringPool.BLANK, friendlyURL);
3345
3346 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
3347 validateName(
3348 group.getGroupId(), group.getCompanyId(), name, group.isSite());
3349 }
3350 else if (className.equals(Organization.class.getName())) {
3351 Organization organization =
3352 organizationPersistence.findByPrimaryKey(classPK);
3353
3354 name = getOrgGroupName(organization.getName());
3355 }
3356 else if (!GroupConstants.USER_PERSONAL_SITE.equals(name)) {
3357 name = String.valueOf(classPK);
3358 }
3359
3360 if (PortalUtil.isSystemGroup(group.getName()) &&
3361 !name.equals(group.getName())) {
3362
3363 throw new RequiredGroupException(
3364 String.valueOf(group.getGroupId()),
3365 RequiredGroupException.SYSTEM_GROUP);
3366 }
3367
3368 validateFriendlyURL(
3369 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
3370 group.getClassPK(), friendlyURL);
3371
3372 validateParentGroup(group.getGroupId(), parentGroupId);
3373
3374 group.setParentGroupId(parentGroupId);
3375 group.setTreePath(group.buildTreePath());
3376 group.setName(name);
3377 group.setDescription(description);
3378 group.setType(type);
3379 group.setManualMembership(manualMembership);
3380 group.setMembershipRestriction(membershipRestriction);
3381 group.setFriendlyURL(friendlyURL);
3382 group.setActive(active);
3383
3384 if ((serviceContext != null) && group.isSite()) {
3385 group.setExpandoBridgeAttributes(serviceContext);
3386 }
3387
3388 groupPersistence.update(group);
3389
3390
3391
3392 if ((serviceContext == null) || !group.isSite()) {
3393 return group;
3394 }
3395
3396 User user = null;
3397
3398 user = userPersistence.fetchByPrimaryKey(group.getCreatorUserId());
3399
3400 if (user == null) {
3401 user = userPersistence.fetchByPrimaryKey(
3402 serviceContext.getUserId());
3403 }
3404
3405 if (user == null) {
3406 user = userLocalService.getDefaultUser(group.getCompanyId());
3407 }
3408
3409 updateAsset(
3410 user.getUserId(), group, serviceContext.getAssetCategoryIds(),
3411 serviceContext.getAssetTagNames());
3412
3413 return group;
3414 }
3415
3416
3427 @Override
3428 public Group updateGroup(long groupId, String typeSettings)
3429 throws PortalException, SystemException {
3430
3431 Group group = groupPersistence.findByPrimaryKey(groupId);
3432
3433 UnicodeProperties oldTypeSettingsProperties =
3434 group.getTypeSettingsProperties();
3435
3436 UnicodeProperties typeSettingsProperties = new UnicodeProperties(true);
3437
3438 typeSettingsProperties.fastLoad(typeSettings);
3439
3440 String newLanguageIds = typeSettingsProperties.getProperty(
3441 PropsKeys.LOCALES);
3442
3443 if (newLanguageIds != null) {
3444 String oldLanguageIds = oldTypeSettingsProperties.getProperty(
3445 PropsKeys.LOCALES, StringPool.BLANK);
3446
3447 String defaultLanguageId = typeSettingsProperties.getProperty(
3448 "languageId", LocaleUtil.toLanguageId(LocaleUtil.getDefault()));
3449
3450 if (!Validator.equals(oldLanguageIds, newLanguageIds)) {
3451 validateLanguageIds(defaultLanguageId, newLanguageIds);
3452
3453 LanguageUtil.resetAvailableGroupLocales(groupId);
3454 }
3455 }
3456
3457 group.setTypeSettings(typeSettings);
3458
3459 groupPersistence.update(group);
3460
3461 return group;
3462 }
3463
3464
3474 @Override
3475 public Group updateSite(long groupId, boolean site)
3476 throws PortalException, SystemException {
3477
3478 Group group = groupPersistence.findByPrimaryKey(groupId);
3479
3480 if (!group.isOrganization()) {
3481 return group;
3482 }
3483
3484 group.setSite(site);
3485
3486 groupPersistence.update(group);
3487
3488 return group;
3489 }
3490
3491 protected void addControlPanelLayouts(Group group)
3492 throws PortalException, SystemException {
3493
3494 long defaultUserId = userLocalService.getDefaultUserId(
3495 group.getCompanyId());
3496
3497 String friendlyURL = getFriendlyURL(
3498 PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
3499
3500 ServiceContext serviceContext = new ServiceContext();
3501
3502 layoutLocalService.addLayout(
3503 defaultUserId, group.getGroupId(), true,
3504 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
3505 PropsValues.CONTROL_PANEL_LAYOUT_NAME, StringPool.BLANK,
3506 StringPool.BLANK, LayoutConstants.TYPE_CONTROL_PANEL, false,
3507 friendlyURL, serviceContext);
3508 }
3509
3510 protected void addDefaultGuestPublicLayoutByProperties(Group group)
3511 throws PortalException, SystemException {
3512
3513 List<Portlet> portlets = portletLocalService.getPortlets(
3514 group.getCompanyId());
3515
3516 if (portlets.isEmpty()) {
3517
3518
3519
3520 return;
3521 }
3522
3523 long defaultUserId = userLocalService.getDefaultUserId(
3524 group.getCompanyId());
3525 String friendlyURL = getFriendlyURL(
3526 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
3527
3528 ServiceContext serviceContext = new ServiceContext();
3529
3530 Layout layout = layoutLocalService.addLayout(
3531 defaultUserId, group.getGroupId(), false,
3532 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
3533 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
3534 StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL,
3535 serviceContext);
3536
3537 LayoutTypePortlet layoutTypePortlet =
3538 (LayoutTypePortlet)layout.getLayoutType();
3539
3540 layoutTypePortlet.setLayoutTemplateId(
3541 0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
3542
3543 for (int i = 0; i < 10; i++) {
3544 String columnId = "column-" + i;
3545 String portletIds = PropsUtil.get(
3546 PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_COLUMN + i);
3547
3548 layoutTypePortlet.addPortletIds(
3549 0, StringUtil.split(portletIds), columnId, false);
3550 }
3551
3552 layoutLocalService.updateLayout(
3553 layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
3554 layout.getTypeSettings());
3555
3556 boolean updateLayoutSet = false;
3557
3558 LayoutSet layoutSet = layout.getLayoutSet();
3559
3560 if (Validator.isNotNull(
3561 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
3562
3563 layoutSet.setThemeId(
3564 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
3565
3566 updateLayoutSet = true;
3567 }
3568
3569 if (Validator.isNotNull(
3570 PropsValues.
3571 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
3572
3573 layoutSet.setColorSchemeId(
3574 PropsValues.
3575 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
3576
3577 updateLayoutSet = true;
3578 }
3579
3580 if (Validator.isNotNull(
3581 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
3582
3583 layoutSet.setWapThemeId(
3584 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
3585
3586 updateLayoutSet = true;
3587 }
3588
3589 if (Validator.isNotNull(
3590 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
3591
3592 layoutSet.setWapColorSchemeId(
3593 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
3594
3595 updateLayoutSet = true;
3596 }
3597
3598 if (updateLayoutSet) {
3599 layoutSetLocalService.updateLayoutSet(layoutSet);
3600 }
3601 }
3602
3603 protected void addDefaultGuestPublicLayouts(Group group)
3604 throws PortalException, SystemException {
3605
3606 if (publicLARFile != null) {
3607 addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
3608 }
3609 else {
3610 addDefaultGuestPublicLayoutByProperties(group);
3611 }
3612 }
3613
3614 protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
3615 throws PortalException, SystemException {
3616
3617 long defaultUserId = userLocalService.getDefaultUserId(
3618 group.getCompanyId());
3619
3620 Map<String, String[]> parameterMap = new HashMap<String, String[]>();
3621
3622 parameterMap.put(
3623 PortletDataHandlerKeys.CATEGORIES,
3624 new String[] {Boolean.TRUE.toString()});
3625 parameterMap.put(
3626 PortletDataHandlerKeys.PERMISSIONS,
3627 new String[] {Boolean.TRUE.toString()});
3628 parameterMap.put(
3629 PortletDataHandlerKeys.PORTLET_CONFIGURATION,
3630 new String[] {Boolean.TRUE.toString()});
3631 parameterMap.put(
3632 PortletDataHandlerKeys.PORTLET_DATA,
3633 new String[] {Boolean.TRUE.toString()});
3634 parameterMap.put(
3635 PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
3636 new String[] {Boolean.TRUE.toString()});
3637
3638 layoutLocalService.importLayouts(
3639 defaultUserId, group.getGroupId(), false, parameterMap, larFile);
3640 }
3641
3642 protected void deletePortletData(Group group)
3643 throws PortalException, SystemException {
3644
3645 List<Portlet> portlets = portletLocalService.getPortlets(
3646 group.getCompanyId());
3647
3648 for (Portlet portlet : portlets) {
3649 if (!portlet.isActive()) {
3650 continue;
3651 }
3652
3653 PortletDataHandler portletDataHandler =
3654 portlet.getPortletDataHandlerInstance();
3655
3656 if ((portletDataHandler == null) ||
3657 portletDataHandler.isDataPortalLevel()) {
3658
3659 continue;
3660 }
3661
3662 PortletDataContext portletDataContext =
3663 PortletDataContextFactoryUtil.createExportPortletDataContext(
3664 group.getCompanyId(), group.getGroupId(),
3665 (Map<String, String[]>)null, (Date)null, (Date)null,
3666 (ZipWriter)null);
3667
3668
3669
3670
3671
3672
3673
3674
3675 portletDataHandler.deleteData(
3676 portletDataContext, portlet.getPortletId(), null);
3677
3684 }
3685 }
3686
3687 protected List<Group> doSearch(
3688 long companyId, long[] classNameIds, long parentGroupId,
3689 String[] names, String[] descriptions,
3690 LinkedHashMap<String, Object> params, boolean andOperator)
3691 throws SystemException {
3692
3693 boolean parentGroupIdEquals = true;
3694
3695 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
3696 parentGroupIdEquals = false;
3697 }
3698
3699 params = new LinkedHashMap<String, Object>(params);
3700
3701 Boolean active = (Boolean)params.remove("active");
3702 List<Long> excludedGroupIds = (List<Long>)params.remove(
3703 "excludedGroupIds");
3704 List<Group> groupsTree = (List<Group>)params.remove("groupsTree");
3705 Boolean manualMembership = (Boolean)params.remove("manualMembership");
3706 Integer membershipRestriction = (Integer)params.remove(
3707 "membershipRestriction");
3708 Boolean site = (Boolean)params.remove("site");
3709 List<Integer> types = (List<Integer>)params.remove("types");
3710
3711 List<Group> groups = new ArrayList<Group>();
3712
3713 for (long classNameId : classNameIds) {
3714 groups.addAll(groupPersistence.findByC_C(companyId, classNameId));
3715 }
3716
3717 Iterator<Group> iterator = groups.iterator();
3718
3719 while (iterator.hasNext()) {
3720 Group group = iterator.next();
3721
3722
3723
3724 long liveGroupId = group.getLiveGroupId();
3725
3726 if (liveGroupId != 0) {
3727 iterator.remove();
3728
3729 continue;
3730 }
3731
3732
3733
3734 long groupParentGroupId = group.getParentGroupId();
3735
3736 if ((parentGroupIdEquals &&
3737 (groupParentGroupId != parentGroupId)) ||
3738 (!parentGroupIdEquals &&
3739 (groupParentGroupId == parentGroupId))) {
3740
3741 iterator.remove();
3742
3743 continue;
3744 }
3745
3746
3747
3748 String name = group.getName();
3749
3750 if (name.equals(GroupConstants.CONTROL_PANEL)) {
3751 iterator.remove();
3752
3753 continue;
3754 }
3755
3756 boolean containsName = matches(name, names);
3757 boolean containsDescription = matches(
3758 group.getDescription(), descriptions);
3759
3760 if ((andOperator && (!containsName || !containsDescription)) ||
3761 (!andOperator && (!containsName && !containsDescription))) {
3762
3763 iterator.remove();
3764
3765 continue;
3766 }
3767
3768
3769
3770 if (active != null) {
3771 if (active != group.isActive()) {
3772 iterator.remove();
3773
3774 continue;
3775 }
3776 }
3777
3778
3779
3780 if ((excludedGroupIds != null) &&
3781 excludedGroupIds.contains(group.getGroupId())) {
3782
3783 iterator.remove();
3784
3785 continue;
3786 }
3787
3788
3789
3790 if (groupsTree != null) {
3791 String treePath = group.getTreePath();
3792
3793 boolean matched = false;
3794
3795 for (Group groupTree : groupsTree) {
3796 String groupTreePath = StringUtil.quote(
3797 String.valueOf(groupTree.getGroupId()),
3798 StringPool.SLASH);
3799
3800 if (treePath.contains(groupTreePath)) {
3801 matched = true;
3802
3803 break;
3804 }
3805 }
3806
3807 if (!matched) {
3808 iterator.remove();
3809
3810 continue;
3811 }
3812 }
3813
3814
3815
3816 if ((manualMembership != null) &&
3817 (manualMembership != group.isManualMembership())) {
3818
3819 iterator.remove();
3820
3821 continue;
3822 }
3823
3824
3825
3826 if ((membershipRestriction != null) &&
3827 (membershipRestriction != group.getMembershipRestriction())) {
3828
3829 iterator.remove();
3830
3831 continue;
3832 }
3833
3834
3835
3836 if (site != null) {
3837 if (site != group.isSite()) {
3838 iterator.remove();
3839
3840 continue;
3841 }
3842 }
3843
3844
3845
3846 int type = group.getType();
3847
3848 if (type == 4) {
3849 iterator.remove();
3850
3851 continue;
3852 }
3853
3854 if ((types != null) && !types.contains(type)) {
3855 iterator.remove();
3856
3857 continue;
3858 }
3859 }
3860
3861 Long userId = (Long)params.remove("usersGroups");
3862
3863 if (userId == null) {
3864 return groups;
3865 }
3866
3867
3868
3869 Set<Group> resultGroups = new HashSet<Group>(groups);
3870
3871 Long roleId = (Long)params.remove("groupsRoles");
3872
3873 if (roleId != null) {
3874 resultGroups.retainAll(rolePersistence.getGroups(roleId));
3875 }
3876
3877
3878
3879 resultGroups.retainAll(userPersistence.getGroups(userId));
3880
3881 boolean inherit = GetterUtil.getBoolean(params.remove("inherit"), true);
3882
3883 if (inherit) {
3884
3885
3886
3887 List<Organization> organizations = userPersistence.getOrganizations(
3888 userId);
3889
3890 for (Organization organization : organizations) {
3891 long organizationId = organization.getOrganizationId();
3892
3893 for (Group group : groups) {
3894 if (organizationId == group.getClassPK()) {
3895 resultGroups.add(group);
3896 }
3897 }
3898 }
3899
3900
3901
3902 for (Organization organization : organizations) {
3903 List<Group> tempGroups = new ArrayList<Group>(groups);
3904
3905 tempGroups.retainAll(
3906 organizationPersistence.getGroups(
3907 organization.getOrganizationId()));
3908
3909 if (!tempGroups.isEmpty()) {
3910 resultGroups.addAll(tempGroups);
3911 }
3912 }
3913
3914
3915
3916 List<UserGroup> userGroups = userPersistence.getUserGroups(userId);
3917
3918 for (UserGroup userGroup : userGroups) {
3919 List<Group> tempGroups = new ArrayList<Group>(groups);
3920
3921 tempGroups.retainAll(
3922 userGroupPersistence.getGroups(userGroup.getUserGroupId()));
3923
3924 if (!tempGroups.isEmpty()) {
3925 resultGroups.addAll(tempGroups);
3926 }
3927 }
3928 }
3929
3930 if (_log.isDebugEnabled() && !params.isEmpty()) {
3931 _log.debug("Unprocessed parameters " + MapUtil.toString(params));
3932 }
3933
3934 return new ArrayList<Group>(resultGroups);
3935 }
3936
3937 protected long[] getClassNameIds() {
3938 if (_classNameIds == null) {
3939 _classNameIds = new long[] {
3940 classNameLocalService.getClassNameId(Group.class),
3941 classNameLocalService.getClassNameId(Organization.class)
3942 };
3943 }
3944
3945 return _classNameIds;
3946 }
3947
3948 protected String getFriendlyURL(
3949 long companyId, long groupId, long classNameId, long classPK,
3950 String friendlyName, String friendlyURL)
3951 throws PortalException, SystemException {
3952
3953 friendlyURL = getFriendlyURL(friendlyURL);
3954
3955 if (Validator.isNotNull(friendlyURL)) {
3956 return friendlyURL;
3957 }
3958
3959 friendlyURL = StringPool.SLASH + getFriendlyURL(friendlyName);
3960
3961 String originalFriendlyURL = friendlyURL;
3962
3963 for (int i = 1;; i++) {
3964 try {
3965 validateFriendlyURL(
3966 companyId, groupId, classNameId, classPK, friendlyURL);
3967
3968 break;
3969 }
3970 catch (GroupFriendlyURLException gfurle) {
3971 int type = gfurle.getType();
3972
3973 if (type == GroupFriendlyURLException.DUPLICATE) {
3974 friendlyURL = originalFriendlyURL + i;
3975 }
3976 else {
3977 friendlyURL = StringPool.SLASH + classPK;
3978
3979 break;
3980 }
3981 }
3982 }
3983
3984 return friendlyURL;
3985 }
3986
3987 protected String getFriendlyURL(String friendlyURL) {
3988 return FriendlyURLNormalizerUtil.normalize(friendlyURL);
3989 }
3990
3991 protected String getOrgGroupName(String name) {
3992 return name + ORGANIZATION_NAME_SUFFIX;
3993 }
3994
3995 protected String[] getSearchNames(long companyId, String name)
3996 throws SystemException {
3997
3998 if (Validator.isNull(name)) {
3999 return new String[] {null};
4000 }
4001
4002 Company company = companyPersistence.fetchByPrimaryKey(companyId);
4003
4004 if (company == null) {
4005 return CustomSQLUtil.keywords(name);
4006 }
4007
4008 Account account = accountPersistence.fetchByPrimaryKey(
4009 company.getAccountId());
4010
4011 if (account == null) {
4012 return CustomSQLUtil.keywords(name);
4013 }
4014
4015 String companyName = account.getName();
4016
4017 if (StringUtil.wildcardMatches(
4018 companyName, name, CharPool.UNDERLINE, CharPool.PERCENT,
4019 CharPool.BACK_SLASH, false)) {
4020
4021 String[] searchNames = CustomSQLUtil.keywords(name);
4022
4023 String guestName = StringUtil.quote(
4024 GroupConstants.GUEST.toLowerCase(), StringPool.PERCENT);
4025
4026 return ArrayUtil.append(searchNames, guestName);
4027 }
4028
4029 return CustomSQLUtil.keywords(name);
4030 }
4031
4032 protected void initImportLARFile() {
4033 String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
4034
4035 if (_log.isDebugEnabled()) {
4036 _log.debug("Reading public LAR file " + publicLARFileName);
4037 }
4038
4039 if (Validator.isNotNull(publicLARFileName)) {
4040 publicLARFile = new File(publicLARFileName);
4041
4042 if (!publicLARFile.exists()) {
4043 _log.error(
4044 "Public LAR file " + publicLARFile + " does not exist");
4045
4046 publicLARFile = null;
4047 }
4048 else {
4049 if (_log.isDebugEnabled()) {
4050 _log.debug("Using public LAR file " + publicLARFileName);
4051 }
4052 }
4053 }
4054 }
4055
4056 protected void initUserPersonalSitePermissions(Group group)
4057 throws PortalException, SystemException {
4058
4059
4060
4061 Role role = roleLocalService.getRole(
4062 group.getCompanyId(), RoleConstants.USER);
4063
4064 List<Portlet> portlets = portletLocalService.getPortlets(
4065 group.getCompanyId(), false, false);
4066
4067 for (Portlet portlet : portlets) {
4068 setRolePermissions(
4069 group, role, portlet.getPortletId(),
4070 new String[] {ActionKeys.VIEW});
4071 }
4072
4073 setRolePermissions(
4074 group, role, Layout.class.getName(),
4075 new String[] {ActionKeys.VIEW});
4076
4077 setRolePermissions(
4078 group, role, "com.liferay.portlet.blogs",
4079 new String[] {
4080 ActionKeys.ADD_ENTRY, ActionKeys.PERMISSIONS,
4081 ActionKeys.SUBSCRIBE});
4082
4083
4084
4085 role = roleLocalService.getRole(
4086 group.getCompanyId(), RoleConstants.POWER_USER);
4087
4088 for (Portlet portlet : portlets) {
4089 List<String> actions =
4090 ResourceActionsUtil.getPortletResourceActions(
4091 portlet.getPortletId());
4092
4093 String controlPanelEntryCategory = GetterUtil.getString(
4094 portlet.getControlPanelEntryCategory());
4095
4096 if (actions.contains(ActionKeys.ACCESS_IN_CONTROL_PANEL) &&
4097 controlPanelEntryCategory.startsWith(
4098 PortletCategoryKeys.SITE_ADMINISTRATION)) {
4099
4100 setRolePermissions(
4101 group, role, portlet.getPortletId(),
4102 new String[] {ActionKeys.ACCESS_IN_CONTROL_PANEL});
4103 }
4104 }
4105
4106 setRolePermissions(
4107 group, role, Group.class.getName(),
4108 new String[] {
4109 ActionKeys.MANAGE_LAYOUTS, ActionKeys.VIEW_SITE_ADMINISTRATION
4110 });
4111
4112 setRolePermissions(group, role, "com.liferay.portlet.asset");
4113 setRolePermissions(group, role, "com.liferay.portlet.blogs");
4114 setRolePermissions(group, role, "com.liferay.portlet.bookmarks");
4115 setRolePermissions(group, role, "com.liferay.portlet.documentlibrary");
4116 setRolePermissions(group, role, "com.liferay.portlet.imagegallery");
4117 setRolePermissions(group, role, "com.liferay.portlet.messageboards");
4118 setRolePermissions(group, role, "com.liferay.portlet.polls");
4119 setRolePermissions(group, role, "com.liferay.portlet.wiki");
4120 }
4121
4122 protected boolean isParentGroup(long parentGroupId, long groupId)
4123 throws PortalException, SystemException {
4124
4125
4126
4127 if (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4128 return false;
4129 }
4130
4131 Group group = groupPersistence.findByPrimaryKey(groupId);
4132
4133 String treePath = group.getTreePath();
4134
4135 if (treePath.contains(
4136 StringPool.SLASH + parentGroupId + StringPool.SLASH)) {
4137
4138 return true;
4139 }
4140 else {
4141 return false;
4142 }
4143 }
4144
4145 protected boolean isStaging(ServiceContext serviceContext) {
4146 if (serviceContext != null) {
4147 return ParamUtil.getBoolean(serviceContext, "staging");
4148 }
4149
4150 return false;
4151 }
4152
4153 protected boolean isUseComplexSQL(long[] classNameIds) {
4154 if (ArrayUtil.isEmpty(classNameIds)) {
4155 return true;
4156 }
4157
4158 if (_complexSQLClassNameIds == null) {
4159 String[] complexSQLClassNames =
4160 PropsValues.GROUPS_COMPLEX_SQL_CLASS_NAMES;
4161
4162 long[] complexSQLClassNameIds =
4163 new long[complexSQLClassNames.length];
4164
4165 for (int i = 0; i < complexSQLClassNames.length; i++) {
4166 String complexSQLClassName = complexSQLClassNames[i];
4167
4168 complexSQLClassNameIds[i] = PortalUtil.getClassNameId(
4169 complexSQLClassName);
4170 }
4171
4172 _complexSQLClassNameIds = complexSQLClassNameIds;
4173 }
4174
4175 for (long classNameId : classNameIds) {
4176 if (ArrayUtil.contains(_complexSQLClassNameIds, classNameId)) {
4177 return true;
4178 }
4179 }
4180
4181 return false;
4182 }
4183
4184 protected boolean matches(String s, String[] keywords) {
4185 if ((keywords == null) ||
4186 ((keywords.length == 1) && (keywords[0] == null))) {
4187
4188 return true;
4189 }
4190
4191 for (String keyword : keywords) {
4192 if (StringUtil.wildcardMatches(
4193 s, keyword, CharPool.UNDERLINE, CharPool.PERCENT,
4194 CharPool.BACK_SLASH, false)) {
4195
4196 return true;
4197 }
4198 }
4199
4200 return false;
4201 }
4202
4203 protected void setCompanyPermissions(
4204 Role role, String name, String[] actionIds)
4205 throws PortalException, SystemException {
4206
4207 if (resourceBlockLocalService.isSupported(name)) {
4208 resourceBlockLocalService.setCompanyScopePermissions(
4209 role.getCompanyId(), name, role.getRoleId(),
4210 Arrays.asList(actionIds));
4211 }
4212 else {
4213 resourcePermissionLocalService.setResourcePermissions(
4214 role.getCompanyId(), name, ResourceConstants.SCOPE_COMPANY,
4215 String.valueOf(role.getCompanyId()), role.getRoleId(),
4216 actionIds);
4217 }
4218 }
4219
4220 protected void setRolePermissions(Group group, Role role, String name)
4221 throws PortalException, SystemException {
4222
4223 List<String> actions = ResourceActionsUtil.getModelResourceActions(
4224 name);
4225
4226 setRolePermissions(
4227 group, role, name, actions.toArray(new String[actions.size()]));
4228 }
4229
4230 protected void setRolePermissions(
4231 Group group, Role role, String name, String[] actionIds)
4232 throws PortalException, SystemException {
4233
4234 if (resourceBlockLocalService.isSupported(name)) {
4235 resourceBlockLocalService.setGroupScopePermissions(
4236 role.getCompanyId(), group.getGroupId(), name, role.getRoleId(),
4237 Arrays.asList(actionIds));
4238 }
4239 else {
4240 resourcePermissionLocalService.setResourcePermissions(
4241 group.getCompanyId(), name, ResourceConstants.SCOPE_GROUP,
4242 String.valueOf(group.getGroupId()), role.getRoleId(),
4243 actionIds);
4244 }
4245 }
4246
4247 protected List<Group> sort(
4248 List<Group> groups, int start, int end, OrderByComparator obc) {
4249
4250 if (obc == null) {
4251 obc = new GroupNameComparator(true);
4252 }
4253
4254 Collections.sort(groups, obc);
4255
4256 return Collections.unmodifiableList(
4257 ListUtil.subList(groups, start, end));
4258 }
4259
4260 protected void unscheduleStaging(Group group) {
4261 try {
4262
4263
4264
4265 String groupName = StagingUtil.getSchedulerGroupName(
4266 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
4267
4268 SchedulerEngineHelperUtil.delete(groupName, StorageType.PERSISTED);
4269
4270 long liveGroupId = 0;
4271 long stagingGroupId = 0;
4272
4273 if (group.isStagingGroup()) {
4274 liveGroupId = group.getLiveGroupId();
4275
4276 stagingGroupId = group.getGroupId();
4277 }
4278 else if (group.hasStagingGroup()) {
4279 liveGroupId = group.getGroupId();
4280
4281 stagingGroupId = group.getStagingGroup().getGroupId();
4282 }
4283
4284 if ((liveGroupId != 0) && (stagingGroupId != 0)) {
4285
4286
4287
4288 groupName = StagingUtil.getSchedulerGroupName(
4289 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
4290
4291 SchedulerEngineHelperUtil.delete(
4292 groupName, StorageType.PERSISTED);
4293
4294
4295
4296 groupName = StagingUtil.getSchedulerGroupName(
4297 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
4298
4299 SchedulerEngineHelperUtil.delete(
4300 groupName, StorageType.PERSISTED);
4301 }
4302 }
4303 catch (Exception e) {
4304 _log.error(
4305 "Unable to unschedule events for group: " + group.getGroupId());
4306 }
4307 }
4308
4309 protected void validateFriendlyURL(
4310 long companyId, long groupId, long classNameId, long classPK,
4311 String friendlyURL)
4312 throws PortalException, SystemException {
4313
4314 Company company = companyPersistence.findByPrimaryKey(companyId);
4315
4316 if (company.isSystem()) {
4317 return;
4318 }
4319
4320 if (Validator.isNull(friendlyURL)) {
4321 return;
4322 }
4323
4324 int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
4325
4326 if (exceptionType != -1) {
4327 throw new GroupFriendlyURLException(exceptionType);
4328 }
4329
4330 Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
4331
4332 if ((group != null) && (group.getGroupId() != groupId)) {
4333 throw new GroupFriendlyURLException(
4334 GroupFriendlyURLException.DUPLICATE);
4335 }
4336
4337 String groupIdFriendlyURL = friendlyURL.substring(1);
4338
4339 if (Validator.isNumber(groupIdFriendlyURL)) {
4340 long groupClassNameId = PortalUtil.getClassNameId(Group.class);
4341
4342 if (((classNameId != groupClassNameId) &&
4343 !groupIdFriendlyURL.equals(String.valueOf(classPK)) &&
4344 !PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC) ||
4345 ((classNameId == groupClassNameId) &&
4346 !groupIdFriendlyURL.equals(String.valueOf(groupId)))) {
4347
4348 GroupFriendlyURLException gfurle =
4349 new GroupFriendlyURLException(
4350 GroupFriendlyURLException.POSSIBLE_DUPLICATE);
4351
4352 gfurle.setKeywordConflict(groupIdFriendlyURL);
4353
4354 throw gfurle;
4355 }
4356 }
4357
4358 String screenName = friendlyURL.substring(1);
4359
4360 User user = userPersistence.fetchByC_SN(companyId, screenName);
4361
4362 if (user != null) {
4363 long userClassNameId = PortalUtil.getClassNameId(User.class);
4364
4365 if ((classNameId == userClassNameId) &&
4366 (classPK == user.getUserId())) {
4367 }
4368 else {
4369 throw new GroupFriendlyURLException(
4370 GroupFriendlyURLException.DUPLICATE);
4371 }
4372 }
4373
4374 if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
4375 throw new GroupFriendlyURLException(
4376 GroupFriendlyURLException.TOO_DEEP);
4377 }
4378 }
4379
4380 protected void validateLanguageIds(
4381 String defaultLanguageId, String languageIds)
4382 throws PortalException {
4383
4384 Locale[] availableLocales = LanguageUtil.getAvailableLocales();
4385
4386 String[] availableLanguageIds = LocaleUtil.toLanguageIds(
4387 availableLocales);
4388
4389 String[] languageIdsArray = StringUtil.split(languageIds);
4390
4391 for (String languageId : languageIdsArray) {
4392 if (!ArrayUtil.contains(availableLanguageIds, languageId)) {
4393 LocaleException le = new LocaleException(
4394 LocaleException.TYPE_DISPLAY_SETTINGS);
4395
4396 le.setSourceAvailableLocales(availableLocales);
4397 le.setTargetAvailableLocales(
4398 LocaleUtil.fromLanguageIds(languageIdsArray));
4399
4400 throw le;
4401 }
4402 }
4403
4404 if (!ArrayUtil.contains(languageIdsArray, defaultLanguageId)) {
4405 LocaleException le = new LocaleException(
4406 LocaleException.TYPE_DEFAULT);
4407
4408 le.setSourceAvailableLocales(availableLocales);
4409 le.setTargetAvailableLocales(
4410 LocaleUtil.fromLanguageIds(languageIdsArray));
4411
4412 throw le;
4413 }
4414 }
4415
4416 protected void validateName(
4417 long groupId, long companyId, String name, boolean site)
4418 throws PortalException, SystemException {
4419
4420 if (Validator.isNull(name) || Validator.isNumber(name) ||
4421 name.contains(StringPool.STAR) ||
4422 name.contains(ORGANIZATION_NAME_SUFFIX)) {
4423
4424 throw new GroupNameException();
4425 }
4426
4427 try {
4428 Group group = groupFinder.findByC_N(companyId, name);
4429
4430 if ((groupId <= 0) || (group.getGroupId() != groupId)) {
4431 throw new DuplicateGroupException();
4432 }
4433 }
4434 catch (NoSuchGroupException nsge) {
4435 }
4436
4437 if (site) {
4438 Company company = companyLocalService.getCompany(companyId);
4439
4440 if (name.equals(company.getName())) {
4441 throw new DuplicateGroupException();
4442 }
4443 }
4444 }
4445
4446 protected void validateParentGroup(long groupId, long parentGroupId)
4447 throws PortalException, SystemException {
4448
4449 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4450 return;
4451 }
4452
4453 if (groupId == parentGroupId) {
4454 throw new GroupParentException(
4455 GroupParentException.SELF_DESCENDANT);
4456 }
4457
4458 Group group = groupPersistence.fetchByPrimaryKey(groupId);
4459
4460 if (group == null) {
4461 return;
4462 }
4463
4464 if ((groupId > 0) &&
4465 (parentGroupId != GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
4466
4467
4468
4469 if (isParentGroup(groupId, parentGroupId)) {
4470 throw new GroupParentException(
4471 GroupParentException.CHILD_DESCENDANT);
4472 }
4473 }
4474
4475 Group parentGroup = groupPersistence.findByPrimaryKey(parentGroupId);
4476
4477 if (group.isStagingGroup()) {
4478 Group stagingGroup = parentGroup.getStagingGroup();
4479
4480 if (groupId == stagingGroup.getGroupId()) {
4481 throw new GroupParentException(
4482 GroupParentException.STAGING_DESCENDANT);
4483 }
4484 }
4485 }
4486
4487 protected File publicLARFile;
4488
4489 private static Log _log = LogFactoryUtil.getLog(
4490 GroupLocalServiceImpl.class);
4491
4492 private volatile long[] _classNameIds;
4493 private volatile long[] _complexSQLClassNameIds;
4494 private Map<String, Group> _systemGroupsMap = new HashMap<String, Group>();
4495
4496 }