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.GroupInheritContentException;
020 import com.liferay.portal.GroupKeyException;
021 import com.liferay.portal.GroupParentException;
022 import com.liferay.portal.LocaleException;
023 import com.liferay.portal.NoSuchGroupException;
024 import com.liferay.portal.NoSuchLayoutSetException;
025 import com.liferay.portal.PendingBackgroundTaskException;
026 import com.liferay.portal.RequiredGroupException;
027 import com.liferay.portal.kernel.backgroundtask.BackgroundTask;
028 import com.liferay.portal.kernel.backgroundtask.BackgroundTaskConstants;
029 import com.liferay.portal.kernel.backgroundtask.BackgroundTaskManagerUtil;
030 import com.liferay.portal.kernel.cache.ThreadLocalCachable;
031 import com.liferay.portal.kernel.dao.orm.QueryUtil;
032 import com.liferay.portal.kernel.exception.PortalException;
033 import com.liferay.portal.kernel.exception.SystemException;
034 import com.liferay.portal.kernel.language.LanguageUtil;
035 import com.liferay.portal.kernel.log.Log;
036 import com.liferay.portal.kernel.log.LogFactoryUtil;
037 import com.liferay.portal.kernel.messaging.DestinationNames;
038 import com.liferay.portal.kernel.scheduler.SchedulerEngineHelperUtil;
039 import com.liferay.portal.kernel.scheduler.StorageType;
040 import com.liferay.portal.kernel.spring.aop.Skip;
041 import com.liferay.portal.kernel.transaction.Propagation;
042 import com.liferay.portal.kernel.transaction.Transactional;
043 import com.liferay.portal.kernel.util.ArrayUtil;
044 import com.liferay.portal.kernel.util.CharPool;
045 import com.liferay.portal.kernel.util.FileUtil;
046 import com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil;
047 import com.liferay.portal.kernel.util.GetterUtil;
048 import com.liferay.portal.kernel.util.GroupThreadLocal;
049 import com.liferay.portal.kernel.util.ListUtil;
050 import com.liferay.portal.kernel.util.LocaleUtil;
051 import com.liferay.portal.kernel.util.MapUtil;
052 import com.liferay.portal.kernel.util.OrderByComparator;
053 import com.liferay.portal.kernel.util.ParamUtil;
054 import com.liferay.portal.kernel.util.PropsKeys;
055 import com.liferay.portal.kernel.util.StringBundler;
056 import com.liferay.portal.kernel.util.StringPool;
057 import com.liferay.portal.kernel.util.StringUtil;
058 import com.liferay.portal.kernel.util.TreeModelTasksAdapter;
059 import com.liferay.portal.kernel.util.TreePathUtil;
060 import com.liferay.portal.kernel.util.UnicodeProperties;
061 import com.liferay.portal.kernel.util.Validator;
062 import com.liferay.portal.kernel.workflow.WorkflowHandler;
063 import com.liferay.portal.kernel.workflow.WorkflowHandlerRegistryUtil;
064 import com.liferay.portal.model.Account;
065 import com.liferay.portal.model.Company;
066 import com.liferay.portal.model.Group;
067 import com.liferay.portal.model.GroupConstants;
068 import com.liferay.portal.model.Layout;
069 import com.liferay.portal.model.LayoutConstants;
070 import com.liferay.portal.model.LayoutPrototype;
071 import com.liferay.portal.model.LayoutSet;
072 import com.liferay.portal.model.LayoutSetPrototype;
073 import com.liferay.portal.model.LayoutTemplate;
074 import com.liferay.portal.model.LayoutTypePortlet;
075 import com.liferay.portal.model.Organization;
076 import com.liferay.portal.model.Portlet;
077 import com.liferay.portal.model.ResourceAction;
078 import com.liferay.portal.model.ResourceConstants;
079 import com.liferay.portal.model.ResourcePermission;
080 import com.liferay.portal.model.ResourceTypePermission;
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.security.permission.RolePermissions;
094 import com.liferay.portal.service.ServiceContext;
095 import com.liferay.portal.service.base.GroupLocalServiceBaseImpl;
096 import com.liferay.portal.theme.ThemeLoader;
097 import com.liferay.portal.theme.ThemeLoaderFactory;
098 import com.liferay.portal.util.PortalUtil;
099 import com.liferay.portal.util.PortletCategoryKeys;
100 import com.liferay.portal.util.PortletKeys;
101 import com.liferay.portal.util.PropsUtil;
102 import com.liferay.portal.util.PropsValues;
103 import com.liferay.portal.util.comparator.GroupIdComparator;
104 import com.liferay.portal.util.comparator.GroupNameComparator;
105 import com.liferay.portlet.exportimport.configuration.ExportImportConfigurationConstants;
106 import com.liferay.portlet.exportimport.configuration.ExportImportConfigurationSettingsMapFactory;
107 import com.liferay.portlet.exportimport.lar.PortletDataContext;
108 import com.liferay.portlet.exportimport.lar.PortletDataContextFactoryUtil;
109 import com.liferay.portlet.exportimport.lar.PortletDataHandler;
110 import com.liferay.portlet.exportimport.lar.PortletDataHandlerKeys;
111 import com.liferay.portlet.exportimport.model.ExportImportConfiguration;
112 import com.liferay.portlet.exportimport.staging.StagingConstants;
113 import com.liferay.portlet.exportimport.staging.StagingUtil;
114 import com.liferay.util.dao.orm.CustomSQLUtil;
115
116 import java.io.File;
117 import java.io.Serializable;
118
119 import java.util.ArrayList;
120 import java.util.Arrays;
121 import java.util.Collection;
122 import java.util.Collections;
123 import java.util.HashMap;
124 import java.util.HashSet;
125 import java.util.Iterator;
126 import java.util.LinkedHashMap;
127 import java.util.List;
128 import java.util.Locale;
129 import java.util.Map;
130 import java.util.Set;
131
132
205 public class GroupLocalServiceImpl extends GroupLocalServiceBaseImpl {
206
207 public static final String ORGANIZATION_NAME_SUFFIX = " LFR_ORGANIZATION";
208
209 public static final String ORGANIZATION_STAGING_SUFFIX = " (Staging)";
210
211
214 public GroupLocalServiceImpl() {
215 initImportLARFile();
216 }
217
218 @Override
219 public Group addGroup(
220 long userId, long parentGroupId, String className, long classPK,
221 long liveGroupId, Map<Locale, String> nameMap,
222 Map<Locale, String> descriptionMap, int type,
223 boolean manualMembership, int membershipRestriction,
224 String friendlyURL, boolean site, boolean inheritContent,
225 boolean active, ServiceContext serviceContext)
226 throws PortalException {
227
228
229
230 User user = userPersistence.findByPrimaryKey(userId);
231 className = GetterUtil.getString(className);
232 long classNameId = classNameLocalService.getClassNameId(className);
233
234 String groupKey = StringPool.BLANK;
235 String friendlyName = StringPool.BLANK;
236
237 if (nameMap != null) {
238 groupKey = nameMap.get(LocaleUtil.getDefault());
239 friendlyName = nameMap.get(LocaleUtil.getDefault());
240 }
241
242 long groupId = 0;
243
244 while (true) {
245 groupId = counterLocalService.increment();
246
247 User screenNameUser = userPersistence.fetchByC_SN(
248 user.getCompanyId(), String.valueOf(groupId));
249
250 if (screenNameUser == null) {
251 break;
252 }
253 }
254
255 boolean staging = isStaging(serviceContext);
256
257 long groupClassNameId = classNameLocalService.getClassNameId(
258 Group.class);
259
260 if ((classNameId <= 0) || className.equals(Group.class.getName()) ||
261 (className.equals(Company.class.getName()) && staging)) {
262
263 className = Group.class.getName();
264 classNameId = groupClassNameId;
265 classPK = groupId;
266 }
267 else if (className.equals(Organization.class.getName())) {
268 groupKey = getOrgGroupName(groupKey);
269 }
270 else if (!GroupConstants.USER_PERSONAL_SITE.equals(groupKey)) {
271 groupKey = String.valueOf(classPK);
272 }
273
274 if (className.equals(Organization.class.getName()) && staging) {
275 classPK = liveGroupId;
276 }
277
278 if (className.equals(Layout.class.getName())) {
279 Layout layout = layoutLocalService.getLayout(classPK);
280
281 parentGroupId = layout.getGroupId();
282 }
283
284 friendlyURL = getFriendlyURL(
285 user.getCompanyId(), groupId, classNameId, classPK, friendlyName,
286 friendlyURL);
287
288 if (staging) {
289 groupKey = groupKey.concat("-staging");
290
291 for (Locale locale : nameMap.keySet()) {
292 String name = nameMap.get(locale);
293
294 if (Validator.isNull(name)) {
295 continue;
296 }
297
298 nameMap.put(locale, name.concat(ORGANIZATION_STAGING_SUFFIX));
299 }
300
301 friendlyURL = getFriendlyURL(friendlyURL.concat("-staging"));
302 }
303
304 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
305 membershipRestriction =
306 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION;
307 }
308
309 if (className.equals(Group.class.getName())) {
310 if (!site && (liveGroupId == 0) &&
311 !groupKey.equals(GroupConstants.CONTROL_PANEL)) {
312
313 throw new IllegalArgumentException();
314 }
315 }
316 else if (!className.equals(Company.class.getName()) &&
317 !className.equals(Organization.class.getName()) &&
318 className.startsWith("com.liferay.portal.model.")) {
319
320 if (site) {
321 throw new IllegalArgumentException();
322 }
323 }
324
325 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
326 validateGroupKey(groupId, user.getCompanyId(), groupKey, site);
327 }
328
329 validateInheritContent(parentGroupId, inheritContent);
330
331 validateFriendlyURL(
332 user.getCompanyId(), groupId, classNameId, classPK, friendlyURL);
333
334 validateParentGroup(groupId, parentGroupId);
335
336 Group group = groupPersistence.create(groupId);
337
338 if (serviceContext != null) {
339 group.setUuid(serviceContext.getUuid());
340 }
341
342 group.setCompanyId(user.getCompanyId());
343 group.setCreatorUserId(userId);
344 group.setClassNameId(classNameId);
345 group.setClassPK(classPK);
346 group.setParentGroupId(parentGroupId);
347 group.setLiveGroupId(liveGroupId);
348 group.setTreePath(group.buildTreePath());
349 group.setGroupKey(groupKey);
350 group.setNameMap(nameMap);
351 group.setDescriptionMap(descriptionMap);
352 group.setType(type);
353 group.setManualMembership(manualMembership);
354 group.setMembershipRestriction(membershipRestriction);
355 group.setFriendlyURL(friendlyURL);
356 group.setInheritContent(inheritContent);
357 group.setSite(site);
358 group.setActive(active);
359
360 if ((serviceContext != null) && (classNameId == groupClassNameId) &&
361 !user.isDefaultUser()) {
362
363 group.setExpandoBridgeAttributes(serviceContext);
364 }
365
366 groupPersistence.update(group);
367
368
369
370 layoutSetLocalService.addLayoutSet(groupId, true);
371
372 layoutSetLocalService.addLayoutSet(groupId, false);
373
374
375
376 resourceLocalService.addResources(
377 group.getCompanyId(), 0, 0, Group.class.getName(),
378 group.getGroupId(), false, false, false);
379
380 if ((classNameId == groupClassNameId) && !user.isDefaultUser()) {
381
382
383
384 Role role = roleLocalService.getRole(
385 group.getCompanyId(), RoleConstants.SITE_OWNER);
386
387 userGroupRoleLocalService.addUserGroupRoles(
388 userId, groupId, new long[] {role.getRoleId()});
389
390
391
392 userLocalService.addGroupUsers(
393 group.getGroupId(), new long[] {userId});
394
395
396
397 if (serviceContext != null) {
398 updateAsset(
399 userId, group, serviceContext.getAssetCategoryIds(),
400 serviceContext.getAssetTagNames());
401 }
402 }
403
404 addPortletDefaultData(group);
405
406 return group;
407 }
408
409 @Override
410 public Group addGroup(
411 long userId, long parentGroupId, String className, long classPK,
412 long liveGroupId, Map<Locale, String> nameMap,
413 Map<Locale, String> descriptionMap, int type,
414 boolean manualMembership, int membershipRestriction,
415 String friendlyURL, boolean site, boolean active,
416 ServiceContext serviceContext)
417 throws PortalException {
418
419 return addGroup(
420 userId, parentGroupId, className, classPK, liveGroupId, nameMap,
421 descriptionMap, type, manualMembership, membershipRestriction,
422 friendlyURL, site, false, active, serviceContext);
423 }
424
425
458 @Deprecated
459 @Override
460 public Group addGroup(
461 long userId, long parentGroupId, String className, long classPK,
462 long liveGroupId, String name, String description, int type,
463 boolean manualMembership, int membershipRestriction,
464 String friendlyURL, boolean site, boolean active,
465 ServiceContext serviceContext)
466 throws PortalException {
467
468 return addGroup(
469 userId, parentGroupId, className, classPK, liveGroupId,
470 getLocalizationMap(name), getLocalizationMap(description), type,
471 manualMembership, membershipRestriction, friendlyURL, site, false,
472 active, serviceContext);
473 }
474
475
502 @Deprecated
503 @Override
504 public Group addGroup(
505 long userId, long parentGroupId, String className, long classPK,
506 String name, String description, int type, String friendlyURL,
507 boolean site, boolean active, ServiceContext serviceContext)
508 throws PortalException {
509
510 return addGroup(
511 userId, parentGroupId, className, classPK,
512 GroupConstants.DEFAULT_LIVE_GROUP_ID, getLocalizationMap(name),
513 getLocalizationMap(description), type, true,
514 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
515 active, serviceContext);
516 }
517
518
546 @Deprecated
547 @Override
548 public Group addGroup(
549 long userId, String className, long classPK, long liveGroupId,
550 String name, String description, int type, String friendlyURL,
551 boolean site, boolean active, ServiceContext serviceContext)
552 throws PortalException {
553
554 return addGroup(
555 userId, GroupConstants.DEFAULT_PARENT_GROUP_ID, className, classPK,
556 liveGroupId, getLocalizationMap(name),
557 getLocalizationMap(description), type, true,
558 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
559 active, serviceContext);
560 }
561
562
588 @Deprecated
589 @Override
590 public Group addGroup(
591 long userId, String className, long classPK, String name,
592 String description, int type, String friendlyURL, boolean site,
593 boolean active, ServiceContext serviceContext)
594 throws PortalException {
595
596 return addGroup(
597 userId, GroupConstants.DEFAULT_PARENT_GROUP_ID, className, classPK,
598 GroupConstants.DEFAULT_LIVE_GROUP_ID, getLocalizationMap(name),
599 getLocalizationMap(description), type, true,
600 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
601 active, serviceContext);
602 }
603
604
610 @Override
611 public void addRoleGroups(long roleId, long[] groupIds) {
612 rolePersistence.addGroups(roleId, groupIds);
613
614 PermissionCacheUtil.clearCache();
615 }
616
617
623 @Override
624 public void addUserGroups(long userId, long[] groupIds) {
625 userPersistence.addGroups(userId, groupIds);
626
627 PermissionCacheUtil.clearCache(userId);
628 }
629
630
640 @Override
641 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
642 public void checkCompanyGroup(long companyId) throws PortalException {
643 long classNameId = classNameLocalService.getClassNameId(Company.class);
644
645 int count = groupPersistence.countByC_C_C(
646 companyId, classNameId, companyId);
647
648 if (count == 0) {
649 long defaultUserId = userLocalService.getDefaultUserId(companyId);
650
651 groupLocalService.addGroup(
652 defaultUserId, GroupConstants.DEFAULT_PARENT_GROUP_ID,
653 Company.class.getName(), companyId,
654 GroupConstants.DEFAULT_LIVE_GROUP_ID,
655 getLocalizationMap(GroupConstants.GLOBAL), null, 0, true,
656 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION,
657 GroupConstants.GLOBAL_FRIENDLY_URL, true, true, null);
658 }
659 }
660
661
669 @Override
670 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
671 public void checkSystemGroups(long companyId) throws PortalException {
672 String companyIdHexString = StringUtil.toHexString(companyId);
673
674 for (Group group : groupFinder.findBySystem(companyId)) {
675 _systemGroupsMap.put(
676 companyIdHexString.concat(group.getGroupKey()), group);
677 }
678
679 long defaultUserId = userLocalService.getDefaultUserId(companyId);
680
681 String[] systemGroups = PortalUtil.getSystemGroups();
682
683 for (String groupKey : systemGroups) {
684 String groupCacheKey = companyIdHexString.concat(groupKey);
685
686 Group group = _systemGroupsMap.get(groupCacheKey);
687
688 if (group == null) {
689 group = groupPersistence.fetchByC_GK(companyId, groupKey);
690 }
691
692 if (group == null) {
693 String className = null;
694 long classPK = 0;
695 int type = GroupConstants.TYPE_SITE_OPEN;
696 String friendlyURL = null;
697 boolean site = true;
698
699 if (groupKey.equals(GroupConstants.CONTROL_PANEL)) {
700 type = GroupConstants.TYPE_SITE_PRIVATE;
701 friendlyURL = GroupConstants.CONTROL_PANEL_FRIENDLY_URL;
702 site = false;
703 }
704 else if (groupKey.equals(GroupConstants.GUEST)) {
705 friendlyURL = "/guest";
706 }
707 else if (groupKey.equals(GroupConstants.USER_PERSONAL_SITE)) {
708 className = UserPersonalSite.class.getName();
709 classPK = defaultUserId;
710 type = GroupConstants.TYPE_SITE_PRIVATE;
711 friendlyURL =
712 GroupConstants.USER_PERSONAL_SITE_FRIENDLY_URL;
713 site = false;
714 }
715
716 group = groupLocalService.addGroup(
717 defaultUserId, GroupConstants.DEFAULT_PARENT_GROUP_ID,
718 className, classPK, GroupConstants.DEFAULT_LIVE_GROUP_ID,
719 getLocalizationMap(groupKey), null, type, true,
720 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL,
721 site, true, null);
722
723 if (groupKey.equals(GroupConstants.USER_PERSONAL_SITE)) {
724 initUserPersonalSitePermissions(group);
725 }
726 }
727
728 if (group.isControlPanel()) {
729 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
730 group.getGroupId(), true);
731
732 if (layoutSet.getPageCount() == 0) {
733 addControlPanelLayouts(group);
734 }
735 }
736
737 if (group.isGuest()) {
738 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
739 group.getGroupId(), false);
740
741 if (layoutSet.getPageCount() == 0) {
742 addDefaultGuestPublicLayouts(group);
743 }
744 }
745
746 _systemGroupsMap.put(groupCacheKey, group);
747 }
748 }
749
750
766 @Override
767 public Group deleteGroup(Group group) throws PortalException {
768 boolean deleteInProcess = GroupThreadLocal.isDeleteInProcess();
769
770 try {
771 GroupThreadLocal.setDeleteInProcess(true);
772
773 if (((group.isCompany() && !group.isCompanyStagingGroup()) ||
774 PortalUtil.isSystemGroup(group.getGroupKey())) &&
775 !CompanyThreadLocal.isDeleteInProcess()) {
776
777 throw new RequiredGroupException.MustNotDeleteSystemGroup(
778 group.getGroupId());
779 }
780
781 if (groupPersistence.countByC_P_S(
782 group.getCompanyId(), group.getGroupId(), true) > 0) {
783
784 throw new RequiredGroupException.MustNotDeleteGroupThatHasChild(
785 group.getGroupId());
786 }
787
788 List<BackgroundTask> backgroundTasks =
789 BackgroundTaskManagerUtil.getBackgroundTasks(
790 group.getGroupId(),
791 BackgroundTaskConstants.STATUS_IN_PROGRESS);
792
793 if (!backgroundTasks.isEmpty()) {
794 throw new PendingBackgroundTaskException(
795 "Unable to delete group with pending background tasks");
796 }
797
798
799
800 BackgroundTaskManagerUtil.deleteGroupBackgroundTasks(
801 group.getGroupId());
802
803
804
805 layoutSetBranchLocalService.deleteLayoutSetBranches(
806 group.getGroupId(), true, true);
807
808 layoutSetBranchLocalService.deleteLayoutSetBranches(
809 group.getGroupId(), false, true);
810
811
812
813 ServiceContext serviceContext = new ServiceContext();
814
815 try {
816 layoutSetLocalService.deleteLayoutSet(
817 group.getGroupId(), true, serviceContext);
818 }
819 catch (NoSuchLayoutSetException nslse) {
820 }
821
822 try {
823 layoutSetLocalService.deleteLayoutSet(
824 group.getGroupId(), false, serviceContext);
825 }
826 catch (NoSuchLayoutSetException nslse) {
827 }
828
829
830
831 membershipRequestLocalService.deleteMembershipRequests(
832 group.getGroupId());
833
834
835
836 portletPreferencesLocalService.deletePortletPreferences(
837 group.getGroupId(), PortletKeys.PREFS_OWNER_TYPE_GROUP,
838 PortletKeys.PREFS_PLID_SHARED);
839
840
841
842 dlAppLocalService.deleteAllRepositories(group.getGroupId());
843
844
845
846 teamLocalService.deleteTeams(group.getGroupId());
847
848
849
850 exportImportConfigurationLocalService.
851 deleteExportImportConfigurations(group.getGroupId());
852
853 unscheduleStaging(group);
854
855 if (group.hasStagingGroup()) {
856 try {
857 stagingLocalService.disableStaging(group, serviceContext);
858 }
859 catch (Exception e) {
860 _log.error(
861 "Unable to disable staging for group " +
862 group.getGroupId());
863 }
864 }
865
866
867
868 ThemeLoader themeLoader =
869 ThemeLoaderFactory.getDefaultThemeLoader();
870
871 if (themeLoader != null) {
872 String themePath =
873 themeLoader.getFileStorage() + StringPool.SLASH +
874 group.getGroupId();
875
876 FileUtil.deltree(themePath + "-private");
877 FileUtil.deltree(themePath + "-public");
878 }
879
880
881
882 deletePortletData(group);
883
884
885
886 if (group.isRegularSite()) {
887 assetEntryLocalService.deleteEntry(
888 Group.class.getName(), group.getGroupId());
889 }
890
891 assetEntryLocalService.deleteGroupEntries(group.getGroupId());
892
893 assetTagLocalService.deleteGroupTags(group.getGroupId());
894
895 assetVocabularyLocalService.deleteVocabularies(group.getGroupId());
896
897
898
899 expandoRowLocalService.deleteRows(group.getGroupId());
900
901
902
903 socialActivityLocalService.deleteActivities(group.getGroupId());
904 socialActivitySettingLocalService.deleteActivitySettings(
905 group.getGroupId());
906 socialRequestLocalService.deleteRequests(
907 classNameLocalService.getClassNameId(Group.class),
908 group.getGroupId());
909
910
911
912 scFrameworkVersionLocalService.deleteFrameworkVersions(
913 group.getGroupId());
914 scProductEntryLocalService.deleteProductEntries(group.getGroupId());
915
916
917
918 List<ResourcePermission> resourcePermissions =
919 resourcePermissionPersistence.findByC_LikeP(
920 group.getCompanyId(), String.valueOf(group.getGroupId()));
921
922 for (ResourcePermission resourcePermission : resourcePermissions) {
923 resourcePermissionLocalService.deleteResourcePermission(
924 resourcePermission);
925 }
926
927 if (!group.isStagingGroup() &&
928 (group.isOrganization() || group.isRegularSite())) {
929
930 resourceLocalService.deleteResource(
931 group.getCompanyId(), Group.class.getName(),
932 ResourceConstants.SCOPE_INDIVIDUAL, group.getGroupId());
933 }
934
935
936
937 trashEntryLocalService.deleteEntries(group.getGroupId());
938
939
940
941 List<WorkflowHandler<?>> scopeableWorkflowHandlers =
942 WorkflowHandlerRegistryUtil.getScopeableWorkflowHandlers();
943
944 for (WorkflowHandler<?> scopeableWorkflowHandler :
945 scopeableWorkflowHandlers) {
946
947 if (!scopeableWorkflowHandler.isVisible()) {
948 continue;
949 }
950
951 WorkflowDefinitionLink workflowDefinitionLink =
952 workflowDefinitionLinkLocalService.
953 fetchWorkflowDefinitionLink(
954 group.getCompanyId(), group.getGroupId(),
955 scopeableWorkflowHandler.getClassName(), 0, 0,
956 true);
957
958 if (workflowDefinitionLink == null) {
959 continue;
960 }
961
962 workflowDefinitionLinkLocalService.deleteWorkflowDefinitionLink(
963 workflowDefinitionLink);
964 }
965
966
967
968 if (!group.isStagingGroup() && group.isOrganization() &&
969 group.isSite()) {
970
971 group.setSite(false);
972
973 groupPersistence.update(group);
974
975
976
977 userGroupRoleLocalService.deleteUserGroupRoles(
978 group.getGroupId(), RoleConstants.TYPE_SITE);
979
980
981
982 userGroupGroupRoleLocalService.deleteUserGroupGroupRoles(
983 group.getGroupId(), RoleConstants.TYPE_SITE);
984 }
985 else {
986 groupPersistence.remove(group);
987
988
989
990 userGroupRoleLocalService.deleteUserGroupRolesByGroupId(
991 group.getGroupId());
992
993
994
995 userGroupGroupRoleLocalService.
996 deleteUserGroupGroupRolesByGroupId(group.getGroupId());
997 }
998
999
1000
1001 PermissionCacheUtil.clearCache();
1002
1003 return group;
1004 }
1005 finally {
1006 GroupThreadLocal.setDeleteInProcess(deleteInProcess);
1007 }
1008 }
1009
1010
1026 @Override
1027 public Group deleteGroup(long groupId) throws PortalException {
1028 Group group = groupPersistence.findByPrimaryKey(groupId);
1029
1030 return deleteGroup(group);
1031 }
1032
1033 @Override
1034 public synchronized void disableStaging(long groupId)
1035 throws PortalException {
1036
1037 Group group = groupPersistence.findByPrimaryKey(groupId);
1038
1039 int stagingGroupCount = group.getRemoteStagingGroupCount();
1040
1041 if (stagingGroupCount > 0) {
1042 stagingGroupCount = stagingGroupCount - 1;
1043
1044 group.setRemoteStagingGroupCount(stagingGroupCount);
1045
1046 if (stagingGroupCount == 0) {
1047 UnicodeProperties typeSettingsProperties =
1048 group.getTypeSettingsProperties();
1049
1050 List<String> keys = new ArrayList<>();
1051
1052 for (String key : typeSettingsProperties.keySet()) {
1053 if (key.startsWith(StagingConstants.STAGED_PORTLET)) {
1054 keys.add(key);
1055 }
1056 }
1057
1058 for (String key : keys) {
1059 typeSettingsProperties.remove(key);
1060 }
1061
1062 group.setTypeSettingsProperties(typeSettingsProperties);
1063 }
1064
1065 groupPersistence.update(group);
1066 }
1067 }
1068
1069 @Override
1070 public synchronized void enableStaging(long groupId)
1071 throws PortalException {
1072
1073 Group group = groupPersistence.findByPrimaryKey(groupId);
1074
1075 int stagingGroupCount = group.getRemoteStagingGroupCount() + 1;
1076
1077 group.setRemoteStagingGroupCount(stagingGroupCount);
1078
1079 groupPersistence.update(group);
1080 }
1081
1082
1089 @Override
1090 public Group fetchCompanyGroup(long companyId) {
1091 long classNameId = classNameLocalService.getClassNameId(Company.class);
1092
1093 return groupPersistence.fetchByC_C_C(companyId, classNameId, companyId);
1094 }
1095
1096
1104 @Override
1105 public Group fetchFriendlyURLGroup(long companyId, String friendlyURL) {
1106 if (Validator.isNull(friendlyURL)) {
1107 return null;
1108 }
1109
1110 friendlyURL = getFriendlyURL(friendlyURL);
1111
1112 return groupPersistence.fetchByC_F(companyId, friendlyURL);
1113 }
1114
1115
1124 @Override
1125 @Skip
1126 public Group fetchGroup(long companyId, String groupKey) {
1127 Group group = _systemGroupsMap.get(
1128 StringUtil.toHexString(companyId).concat(groupKey));
1129
1130 if (group != null) {
1131 return group;
1132 }
1133
1134 return groupLocalService.loadFetchGroup(companyId, groupKey);
1135 }
1136
1137 @Override
1138 public Group fetchUserGroup(long companyId, long userId) {
1139 long classNameId = classNameLocalService.getClassNameId(User.class);
1140
1141 return groupPersistence.fetchByC_C_C(companyId, classNameId, userId);
1142 }
1143
1144
1153 @Override
1154 public Group fetchUserPersonalSiteGroup(long companyId)
1155 throws PortalException {
1156
1157 long classNameId = classNameLocalService.getClassNameId(
1158 UserPersonalSite.class);
1159 long defaultUserId = userLocalService.getDefaultUserId(companyId);
1160
1161 return groupPersistence.fetchByC_C_C(
1162 companyId, classNameId, defaultUserId);
1163 }
1164
1165
1172 @Override
1173 public Group getCompanyGroup(long companyId) throws PortalException {
1174 long classNameId = classNameLocalService.getClassNameId(Company.class);
1175
1176 return groupPersistence.findByC_C_C(companyId, classNameId, companyId);
1177 }
1178
1179
1197 @Override
1198 public List<Group> getCompanyGroups(long companyId, int start, int end) {
1199 return groupPersistence.findByCompanyId(companyId, start, end);
1200 }
1201
1202
1208 @Override
1209 public int getCompanyGroupsCount(long companyId) {
1210 return groupPersistence.countByCompanyId(companyId);
1211 }
1212
1213
1222 @Override
1223 public Group getFriendlyURLGroup(long companyId, String friendlyURL)
1224 throws PortalException {
1225
1226 if (Validator.isNull(friendlyURL)) {
1227 StringBundler sb = new StringBundler(5);
1228
1229 sb.append("{companyId=");
1230 sb.append(companyId);
1231 sb.append(", friendlyURL=");
1232 sb.append(friendlyURL);
1233 sb.append("}");
1234
1235 throw new NoSuchGroupException(sb.toString());
1236 }
1237
1238 friendlyURL = getFriendlyURL(friendlyURL);
1239
1240 return groupPersistence.findByC_F(companyId, friendlyURL);
1241 }
1242
1243
1251 @Override
1252 @ThreadLocalCachable
1253 public Group getGroup(long groupId) throws PortalException {
1254 return groupPersistence.findByPrimaryKey(groupId);
1255 }
1256
1257
1265 @Override
1266 @Skip
1267 public Group getGroup(long companyId, String groupKey)
1268 throws PortalException {
1269
1270 Group group = _systemGroupsMap.get(
1271 StringUtil.toHexString(companyId).concat(groupKey));
1272
1273 if (group != null) {
1274 return group;
1275 }
1276
1277 return groupLocalService.loadGetGroup(companyId, groupKey);
1278 }
1279
1280
1284 @Deprecated
1285 @Override
1286 public String getGroupDescriptiveName(Group group, Locale locale)
1287 throws PortalException {
1288
1289 return group.getDescriptiveName(locale);
1290 }
1291
1292
1296 @Deprecated
1297 @Override
1298 public String getGroupDescriptiveName(long groupId, Locale locale)
1299 throws PortalException {
1300
1301 Group group = groupPersistence.findByPrimaryKey(groupId);
1302
1303 return group.getDescriptiveName(locale);
1304 }
1305
1306
1315 @Override
1316 public List<Group> getGroups(
1317 long companyId, long parentGroupId, boolean site) {
1318
1319 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
1320 return groupPersistence.findByC_S(companyId, site);
1321 }
1322
1323 return groupPersistence.findByC_P_S(companyId, parentGroupId, site);
1324 }
1325
1326 @Override
1327 public List<Group> getGroups(
1328 long companyId, long parentGroupId, boolean site,
1329 boolean inheritContent) {
1330
1331 return groupPersistence.findByC_P_S_I(
1332 companyId, parentGroupId, site, inheritContent);
1333 }
1334
1335
1345 @Override
1346 public List<Group> getGroups(
1347 long companyId, String className, long parentGroupId) {
1348
1349 long classNameId = classNameLocalService.getClassNameId(className);
1350
1351 return groupPersistence.findByC_C_P(
1352 companyId, classNameId, parentGroupId);
1353 }
1354
1355
1366 @Override
1367 public List<Group> getGroups(
1368 long companyId, String className, long parentGroupId, int start,
1369 int end) {
1370
1371 long classNameId = classNameLocalService.getClassNameId(className);
1372
1373 return groupPersistence.findByC_C_P(
1374 companyId, classNameId, parentGroupId, start, end);
1375 }
1376
1377
1384 @Override
1385 public List<Group> getGroups(long[] groupIds) throws PortalException {
1386 List<Group> groups = new ArrayList<>(groupIds.length);
1387
1388 for (long groupId : groupIds) {
1389 Group group = getGroup(groupId);
1390
1391 groups.add(group);
1392 }
1393
1394 return groups;
1395 }
1396
1397
1406 @Override
1407 public int getGroupsCount(
1408 long companyId, long parentGroupId, boolean site) {
1409
1410 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
1411 return groupPersistence.countByC_S(companyId, site);
1412 }
1413
1414 return groupPersistence.countByC_P_S(companyId, parentGroupId, site);
1415 }
1416
1417
1426 @Override
1427 public int getGroupsCount(
1428 long companyId, String className, long parentGroupId) {
1429
1430 long classNameId = classNameLocalService.getClassNameId(className);
1431
1432 return groupPersistence.countByC_C_P(
1433 companyId, classNameId, parentGroupId);
1434 }
1435
1436
1444 @Override
1445 public Group getLayoutGroup(long companyId, long plid)
1446 throws PortalException {
1447
1448 long classNameId = classNameLocalService.getClassNameId(Layout.class);
1449
1450 return groupPersistence.findByC_C_C(companyId, classNameId, plid);
1451 }
1452
1453
1461 @Override
1462 public Group getLayoutPrototypeGroup(long companyId, long layoutPrototypeId)
1463 throws PortalException {
1464
1465 long classNameId = classNameLocalService.getClassNameId(
1466 LayoutPrototype.class);
1467
1468 return groupPersistence.findByC_C_C(
1469 companyId, classNameId, layoutPrototypeId);
1470 }
1471
1472
1480 @Override
1481 public Group getLayoutSetPrototypeGroup(
1482 long companyId, long layoutSetPrototypeId)
1483 throws PortalException {
1484
1485 long classNameId = classNameLocalService.getClassNameId(
1486 LayoutSetPrototype.class);
1487
1488 return groupPersistence.findByC_C_C(
1489 companyId, classNameId, layoutSetPrototypeId);
1490 }
1491
1492
1515 @Deprecated
1516 @Override
1517 public List<Group> getLayoutsGroups(
1518 long companyId, long parentGroupId, boolean site, int start, int end) {
1519
1520 return getLayoutsGroups(
1521 companyId, parentGroupId, site, start, end, null);
1522 }
1523
1524
1548 @Override
1549 public List<Group> getLayoutsGroups(
1550 long companyId, long parentGroupId, boolean site, int start, int end,
1551 OrderByComparator<Group> obc) {
1552
1553 return groupFinder.findByLayouts(
1554 companyId, parentGroupId, site, start, end, obc);
1555 }
1556
1557
1566 @Override
1567 public int getLayoutsGroupsCount(
1568 long companyId, long parentGroupId, boolean site) {
1569
1570 return groupFinder.countByLayouts(companyId, parentGroupId, site);
1571 }
1572
1573
1578 @Override
1579 public List<Group> getLiveGroups() {
1580 return groupFinder.findByLiveGroups();
1581 }
1582
1583
1604 @Override
1605 public List<Group> getNoLayoutsGroups(
1606 String className, boolean privateLayout, int start, int end) {
1607
1608 long classNameId = classNameLocalService.getClassNameId(className);
1609
1610 return groupFinder.findByNoLayouts(
1611 classNameId, privateLayout, start, end);
1612 }
1613
1614
1621 @Override
1622 public List<Group> getNullFriendlyURLGroups() {
1623 return groupFinder.findByNullFriendlyURL();
1624 }
1625
1626
1634 @Override
1635 public Group getOrganizationGroup(long companyId, long organizationId)
1636 throws PortalException {
1637
1638 long classNameId = classNameLocalService.getClassNameId(
1639 Organization.class);
1640
1641 return groupPersistence.findByC_C_C(
1642 companyId, classNameId, organizationId);
1643 }
1644
1645
1651 @Override
1652 public List<Group> getOrganizationsGroups(
1653 List<Organization> organizations) {
1654
1655 List<Group> organizationGroups = new ArrayList<>();
1656
1657 for (int i = 0; i < organizations.size(); i++) {
1658 Organization organization = organizations.get(i);
1659
1660 Group group = organization.getGroup();
1661
1662 organizationGroups.add(group);
1663 }
1664
1665 return organizationGroups;
1666 }
1667
1668
1674 @Override
1675 public List<Group> getOrganizationsRelatedGroups(
1676 List<Organization> organizations) {
1677
1678 List<Group> organizationGroups = new ArrayList<>();
1679
1680 for (int i = 0; i < organizations.size(); i++) {
1681 Organization organization = organizations.get(i);
1682
1683 List<Group> groups = organizationPersistence.getGroups(
1684 organization.getOrganizationId());
1685
1686 organizationGroups.addAll(groups);
1687 }
1688
1689 return organizationGroups;
1690 }
1691
1692
1702 @Override
1703 public List<Group> getParentGroups(long groupId) throws PortalException {
1704 if (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
1705 return new ArrayList<>();
1706 }
1707
1708 Group group = groupPersistence.findByPrimaryKey(groupId);
1709
1710 return group.getAncestors();
1711 }
1712
1713
1720 @Override
1721 public Group getStagingGroup(long liveGroupId) throws PortalException {
1722 return groupPersistence.findByLiveGroupId(liveGroupId);
1723 }
1724
1725
1733 @Override
1734 public Group getUserGroup(long companyId, long userId)
1735 throws PortalException {
1736
1737 long classNameId = classNameLocalService.getClassNameId(User.class);
1738
1739 return groupPersistence.findByC_C_C(companyId, classNameId, userId);
1740 }
1741
1742
1751 @Override
1752 public Group getUserGroupGroup(long companyId, long userGroupId)
1753 throws PortalException {
1754
1755 long classNameId = classNameLocalService.getClassNameId(
1756 UserGroup.class);
1757
1758 return groupPersistence.findByC_C_C(
1759 companyId, classNameId, userGroupId);
1760 }
1761
1762
1773 @Override
1774 public List<Group> getUserGroups(long userId, boolean inherit)
1775 throws PortalException {
1776
1777 return getUserGroups(
1778 userId, inherit, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1779 }
1780
1781
1806 @Override
1807 public List<Group> getUserGroups(
1808 long userId, boolean inherit, int start, int end)
1809 throws PortalException {
1810
1811 if (inherit) {
1812 User user = userPersistence.findByPrimaryKey(userId);
1813
1814 LinkedHashMap<String, Object> groupParams = new LinkedHashMap<>();
1815
1816 groupParams.put("usersGroups", Long.valueOf(userId));
1817
1818 return search(
1819 user.getCompanyId(), null, null, groupParams, start, end);
1820 }
1821 else {
1822 return userPersistence.getGroups(userId, start, end);
1823 }
1824 }
1825
1826
1834 @Override
1835 public List<Group> getUserGroupsGroups(List<UserGroup> userGroups)
1836 throws PortalException {
1837
1838 List<Group> userGroupGroups = new ArrayList<>();
1839
1840 for (int i = 0; i < userGroups.size(); i++) {
1841 UserGroup userGroup = userGroups.get(i);
1842
1843 Group group = userGroup.getGroup();
1844
1845 userGroupGroups.add(group);
1846 }
1847
1848 return userGroupGroups;
1849 }
1850
1851
1857 @Override
1858 public List<Group> getUserGroupsRelatedGroups(List<UserGroup> userGroups) {
1859 List<Group> userGroupGroups = new ArrayList<>();
1860
1861 for (int i = 0; i < userGroups.size(); i++) {
1862 UserGroup userGroup = userGroups.get(i);
1863
1864 List<Group> groups = userGroupPersistence.getGroups(
1865 userGroup.getUserGroupId());
1866
1867 userGroupGroups.addAll(groups);
1868 }
1869
1870 return userGroupGroups;
1871 }
1872
1873
1897 @Override
1898 public List<Group> getUserOrganizationsGroups(
1899 long userId, int start, int end)
1900 throws PortalException {
1901
1902 List<Group> userOrgsGroups = new ArrayList<>();
1903
1904 List<Organization> userOrgs =
1905 organizationLocalService.getUserOrganizations(userId, start, end);
1906
1907 for (Organization organization : userOrgs) {
1908 userOrgsGroups.add(0, organization.getGroup());
1909
1910 if (!PropsValues.ORGANIZATIONS_MEMBERSHIP_STRICT) {
1911 for (Organization ancestorOrganization :
1912 organization.getAncestors()) {
1913
1914 userOrgsGroups.add(0, ancestorOrganization.getGroup());
1915 }
1916 }
1917 }
1918
1919 return ListUtil.unique(userOrgsGroups);
1920 }
1921
1922
1930 @Override
1931 public Group getUserPersonalSiteGroup(long companyId)
1932 throws PortalException {
1933
1934 long classNameId = classNameLocalService.getClassNameId(
1935 UserPersonalSite.class);
1936 long defaultUserId = userLocalService.getDefaultUserId(companyId);
1937
1938 return groupPersistence.findByC_C_C(
1939 companyId, classNameId, defaultUserId);
1940 }
1941
1942 @Override
1943 public List<Group> getUserSitesGroups(long userId) throws PortalException {
1944 User user = userPersistence.findByPrimaryKey(userId);
1945
1946 LinkedHashMap<String, Object> groupParams = new LinkedHashMap<>();
1947
1948 groupParams.put("inherit", Boolean.TRUE);
1949 groupParams.put("site", Boolean.TRUE);
1950 groupParams.put("usersGroups", userId);
1951
1952 return groupFinder.findByCompanyId(
1953 user.getCompanyId(), groupParams, QueryUtil.ALL_POS,
1954 QueryUtil.ALL_POS, new GroupNameComparator(true));
1955 }
1956
1957 @Override
1958 public List<Group> getUserSitesGroups(
1959 long userId, boolean includeAdministrative)
1960 throws PortalException {
1961
1962 if (!includeAdministrative) {
1963 return getUserSitesGroups(userId);
1964 }
1965
1966 Set<Group> sites = new HashSet<>();
1967
1968 List<UserGroupRole> userGroupRoles =
1969 userGroupRoleLocalService.getUserGroupRoles(userId);
1970
1971 for (UserGroupRole userGroupRole : userGroupRoles) {
1972 Role role = userGroupRole.getRole();
1973
1974 String roleName = role.getName();
1975
1976 if (roleName.equals(RoleConstants.SITE_ADMINISTRATOR) ||
1977 roleName.equals(RoleConstants.SITE_OWNER)) {
1978
1979 Group group = userGroupRole.getGroup();
1980
1981 sites.add(group);
1982 }
1983 }
1984
1985 sites.addAll(getUserSitesGroups(userId));
1986
1987 return new ArrayList<>(sites);
1988 }
1989
1990
1997 @Override
1998 public boolean hasStagingGroup(long liveGroupId) {
1999 if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
2000 return true;
2001 }
2002 else {
2003 return false;
2004 }
2005 }
2006
2007
2017 @Override
2018 public boolean hasUserGroup(long userId, long groupId) {
2019 return hasUserGroup(userId, groupId, true);
2020 }
2021
2022
2034 @Override
2035 public boolean hasUserGroup(long userId, long groupId, boolean inherit) {
2036 if (groupFinder.countByG_U(groupId, userId, inherit) > 0) {
2037 return true;
2038 }
2039 else {
2040 return false;
2041 }
2042 }
2043
2044
2053 @Override
2054 public Group loadFetchGroup(long companyId, String groupKey) {
2055 return groupPersistence.fetchByC_GK(companyId, groupKey);
2056 }
2057
2058
2066 @Override
2067 public Group loadGetGroup(long companyId, String groupKey)
2068 throws PortalException {
2069
2070 return groupPersistence.findByC_GK(companyId, groupKey);
2071 }
2072
2073
2086 @Override
2087 public void rebuildTree(long companyId) throws PortalException {
2088 TreePathUtil.rebuildTree(
2089 companyId, GroupConstants.DEFAULT_PARENT_GROUP_ID, StringPool.SLASH,
2090 new TreeModelTasksAdapter<Group>() {
2091
2092 @Override
2093 public List<Group> findTreeModels(
2094 long previousId, long companyId, long parentPrimaryKey,
2095 int size) {
2096
2097 return groupPersistence.findByG_C_P(
2098 previousId, companyId, parentPrimaryKey,
2099 QueryUtil.ALL_POS, size, new GroupIdComparator(true));
2100 }
2101
2102 }
2103 );
2104 }
2105
2106
2133 @Override
2134 public List<Group> search(
2135 long companyId, LinkedHashMap<String, Object> params, int start,
2136 int end) {
2137
2138 return groupFinder.findByCompanyId(
2139 companyId, params, start, end, new GroupNameComparator(true));
2140 }
2141
2142
2172 @Override
2173 public List<Group> search(
2174 long companyId, long parentGroupId, String keywords,
2175 LinkedHashMap<String, Object> params, int start, int end) {
2176
2177 return search(
2178 companyId, getClassNameIds(), parentGroupId, keywords, params,
2179 start, end, null);
2180 }
2181
2182
2214 @Override
2215 public List<Group> search(
2216 long companyId, long parentGroupId, String keywords,
2217 LinkedHashMap<String, Object> params, int start, int end,
2218 OrderByComparator<Group> obc) {
2219
2220 return search(
2221 companyId, getClassNameIds(), parentGroupId, keywords, params,
2222 start, end, obc);
2223 }
2224
2225
2258 @Override
2259 public List<Group> search(
2260 long companyId, long parentGroupId, String name, String description,
2261 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2262 int end) {
2263
2264 return search(
2265 companyId, getClassNameIds(), parentGroupId, name, description,
2266 params, andOperator, start, end, null);
2267 }
2268
2269
2304 @Override
2305 public List<Group> search(
2306 long companyId, long parentGroupId, String name, String description,
2307 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2308 int end, OrderByComparator<Group> obc) {
2309
2310 return search(
2311 companyId, getClassNameIds(), parentGroupId, name, description,
2312 params, andOperator, start, end, obc);
2313 }
2314
2315
2348 @Override
2349 public List<Group> search(
2350 long companyId, long[] classNameIds, long parentGroupId,
2351 String keywords, LinkedHashMap<String, Object> params, int start,
2352 int end) {
2353
2354 return search(
2355 companyId, classNameIds, parentGroupId, keywords, params, start,
2356 end, null);
2357 }
2358
2359
2394 @Override
2395 public List<Group> search(
2396 long companyId, long[] classNameIds, long parentGroupId,
2397 String keywords, LinkedHashMap<String, Object> params, int start,
2398 int end, OrderByComparator<Group> obc) {
2399
2400 String[] keywordsArray = getSearchNames(companyId, keywords);
2401
2402 boolean andOperator = false;
2403
2404 if (Validator.isNull(keywords)) {
2405 andOperator = true;
2406 }
2407
2408 if (isUseComplexSQL(classNameIds)) {
2409 return groupFinder.findByC_C_PG_N_D(
2410 companyId, classNameIds, parentGroupId, keywordsArray,
2411 keywordsArray, params, andOperator, start, end, obc);
2412 }
2413
2414 Collection<Group> groups = doSearch(
2415 companyId, classNameIds, parentGroupId, keywordsArray,
2416 keywordsArray, params, andOperator);
2417
2418 return sort(groups, start, end, obc);
2419 }
2420
2421
2457 @Override
2458 public List<Group> search(
2459 long companyId, long[] classNameIds, long parentGroupId, String name,
2460 String description, LinkedHashMap<String, Object> params,
2461 boolean andOperator, int start, int end) {
2462
2463 return search(
2464 companyId, classNameIds, parentGroupId, name, description, params,
2465 andOperator, start, end, null);
2466 }
2467
2468
2506 @Override
2507 public List<Group> search(
2508 long companyId, long[] classNameIds, long parentGroupId, String name,
2509 String description, LinkedHashMap<String, Object> params,
2510 boolean andOperator, int start, int end, OrderByComparator<Group> obc) {
2511
2512 String[] names = getSearchNames(companyId, name);
2513 String[] descriptions = CustomSQLUtil.keywords(description);
2514
2515 if (isUseComplexSQL(classNameIds)) {
2516 return groupFinder.findByC_C_PG_N_D(
2517 companyId, classNameIds, parentGroupId, names, descriptions,
2518 params, andOperator, start, end, obc);
2519 }
2520
2521 Collection<Group> groups = doSearch(
2522 companyId, classNameIds, parentGroupId, names, descriptions, params,
2523 andOperator);
2524
2525 return sort(groups, start, end, obc);
2526 }
2527
2528
2559 @Override
2560 public List<Group> search(
2561 long companyId, long[] classNameIds, String keywords,
2562 LinkedHashMap<String, Object> params, int start, int end) {
2563
2564 return search(
2565 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
2566 keywords, params, start, end, null);
2567 }
2568
2569
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<Group> obc) {
2607
2608 return search(
2609 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
2610 keywords, params, start, end, obc);
2611 }
2612
2613
2648 @Override
2649 public List<Group> search(
2650 long companyId, long[] classNameIds, String name, String description,
2651 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2652 int end) {
2653
2654 return search(
2655 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
2656 description, params, andOperator, start, end, null);
2657 }
2658
2659
2696 @Override
2697 public List<Group> search(
2698 long companyId, long[] classNameIds, String name, String description,
2699 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2700 int end, OrderByComparator<Group> obc) {
2701
2702 return search(
2703 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
2704 description, params, andOperator, start, end, obc);
2705 }
2706
2707
2735 @Override
2736 @ThreadLocalCachable
2737 public List<Group> search(
2738 long companyId, String keywords, LinkedHashMap<String, Object> params,
2739 int start, int end) {
2740
2741 return search(
2742 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2743 keywords, params, start, end, null);
2744 }
2745
2746
2776 @Override
2777 public List<Group> search(
2778 long companyId, String keywords, LinkedHashMap<String, Object> params,
2779 int start, int end, OrderByComparator<Group> obc) {
2780
2781 return search(
2782 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2783 keywords, params, start, end, obc);
2784 }
2785
2786
2818 @Override
2819 public List<Group> search(
2820 long companyId, String name, String description,
2821 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2822 int end) {
2823
2824 return search(
2825 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2826 name, description, params, andOperator, start, end, null);
2827 }
2828
2829
2863 @Override
2864 public List<Group> search(
2865 long companyId, String name, String description,
2866 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2867 int end, OrderByComparator<Group> obc) {
2868
2869 return search(
2870 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2871 name, description, params, andOperator, start, end, obc);
2872 }
2873
2874
2891 @Override
2892 @ThreadLocalCachable
2893 public int searchCount(
2894 long companyId, long parentGroupId, String keywords,
2895 LinkedHashMap<String, Object> params) {
2896
2897 return searchCount(
2898 companyId, getClassNameIds(), parentGroupId, keywords, params);
2899 }
2900
2901
2922 @Override
2923 @ThreadLocalCachable
2924 public int searchCount(
2925 long companyId, long parentGroupId, String name, String description,
2926 LinkedHashMap<String, Object> params, boolean andOperator) {
2927
2928 return searchCount(
2929 companyId, getClassNameIds(), parentGroupId, name, description,
2930 params, andOperator);
2931 }
2932
2933
2953 @Override
2954 @ThreadLocalCachable
2955 public int searchCount(
2956 long companyId, long[] classNameIds, long parentGroupId,
2957 String keywords, LinkedHashMap<String, Object> params) {
2958
2959 String[] keywordsArray = getSearchNames(companyId, keywords);
2960
2961 boolean andOperator = false;
2962
2963 if (Validator.isNull(keywords)) {
2964 andOperator = true;
2965 }
2966
2967 if (isUseComplexSQL(classNameIds)) {
2968 return groupFinder.countByC_C_PG_N_D(
2969 companyId, classNameIds, parentGroupId, keywordsArray,
2970 keywordsArray, params, andOperator);
2971 }
2972
2973 Collection<Group> groups = doSearch(
2974 companyId, classNameIds, parentGroupId, keywordsArray,
2975 keywordsArray, params, andOperator);
2976
2977 return groups.size();
2978 }
2979
2980
3003 @Override
3004 @ThreadLocalCachable
3005 public int searchCount(
3006 long companyId, long[] classNameIds, long parentGroupId, String name,
3007 String description, LinkedHashMap<String, Object> params,
3008 boolean andOperator) {
3009
3010 String[] names = getSearchNames(companyId, name);
3011 String[] descriptions = CustomSQLUtil.keywords(description);
3012
3013 if (isUseComplexSQL(classNameIds)) {
3014 return groupFinder.countByC_C_PG_N_D(
3015 companyId, classNameIds, parentGroupId, names, descriptions,
3016 params, andOperator);
3017 }
3018
3019 Collection<Group> groups = doSearch(
3020 companyId, classNameIds, parentGroupId, names, descriptions, params,
3021 andOperator);
3022
3023 return groups.size();
3024 }
3025
3026
3044 @Override
3045 @ThreadLocalCachable
3046 public int searchCount(
3047 long companyId, long[] classNameIds, String keywords,
3048 LinkedHashMap<String, Object> params) {
3049
3050 return searchCount(
3051 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
3052 keywords, params);
3053 }
3054
3055
3076 @Override
3077 @ThreadLocalCachable
3078 public int searchCount(
3079 long companyId, long[] classNameIds, String name, String description,
3080 LinkedHashMap<String, Object> params, boolean andOperator) {
3081
3082 return searchCount(
3083 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
3084 description, params, andOperator);
3085 }
3086
3087
3103 @Override
3104 @ThreadLocalCachable
3105 public int searchCount(
3106 long companyId, String keywords, LinkedHashMap<String, Object> params) {
3107
3108 return searchCount(
3109 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
3110 keywords, params);
3111 }
3112
3113
3133 @Override
3134 @ThreadLocalCachable
3135 public int searchCount(
3136 long companyId, String name, String description,
3137 LinkedHashMap<String, Object> params, boolean andOperator) {
3138
3139 return searchCount(
3140 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
3141 name, description, params, andOperator);
3142 }
3143
3144
3151 @Override
3152 public void setRoleGroups(long roleId, long[] groupIds) {
3153 rolePersistence.setGroups(roleId, groupIds);
3154
3155 PermissionCacheUtil.clearCache();
3156 }
3157
3158
3164 @Override
3165 public void unsetRoleGroups(long roleId, long[] groupIds) {
3166 rolePersistence.removeGroups(roleId, groupIds);
3167
3168 PermissionCacheUtil.clearCache();
3169 }
3170
3171
3177 @Override
3178 public void unsetUserGroups(long userId, long[] groupIds) {
3179 userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
3180
3181 userPersistence.removeGroups(userId, groupIds);
3182
3183 PermissionCacheUtil.clearCache(userId);
3184 }
3185
3186
3196 @Override
3197 public void updateAsset(
3198 long userId, Group group, long[] assetCategoryIds,
3199 String[] assetTagNames)
3200 throws PortalException {
3201
3202 User user = userPersistence.findByPrimaryKey(userId);
3203
3204 Company company = companyPersistence.findByPrimaryKey(
3205 user.getCompanyId());
3206
3207 Group companyGroup = company.getGroup();
3208
3209 assetEntryLocalService.updateEntry(
3210 userId, companyGroup.getGroupId(), null, null,
3211 Group.class.getName(), group.getGroupId(), null, 0,
3212 assetCategoryIds, assetTagNames, false, null, null, null, null,
3213 group.getDescriptiveName(), group.getDescription(), null, null,
3214 null, 0, 0, null);
3215 }
3216
3217
3228 @Override
3229 public Group updateFriendlyURL(long groupId, String friendlyURL)
3230 throws PortalException {
3231
3232 Group group = groupPersistence.findByPrimaryKey(groupId);
3233
3234 if (group.isUser()) {
3235 User user = userPersistence.findByPrimaryKey(group.getClassPK());
3236
3237 friendlyURL = StringPool.SLASH + user.getScreenName();
3238
3239 if (group.getFriendlyURL().equals(friendlyURL)) {
3240 return group;
3241 }
3242 }
3243
3244 friendlyURL = getFriendlyURL(
3245 group.getCompanyId(), groupId, group.getClassNameId(),
3246 group.getClassPK(), StringPool.BLANK, friendlyURL);
3247
3248 validateFriendlyURL(
3249 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
3250 group.getClassPK(), friendlyURL);
3251
3252 group.setFriendlyURL(friendlyURL);
3253
3254 groupPersistence.update(group);
3255
3256 return group;
3257 }
3258
3259 @Override
3260 public Group updateGroup(
3261 long groupId, long parentGroupId, Map<Locale, String> nameMap,
3262 Map<Locale, String> descriptionMap, int type,
3263 boolean manualMembership, int membershipRestriction,
3264 String friendlyURL, boolean inheritContent, boolean active,
3265 ServiceContext serviceContext)
3266 throws PortalException {
3267
3268 Group group = groupPersistence.findByPrimaryKey(groupId);
3269
3270 String className = group.getClassName();
3271 long classNameId = group.getClassNameId();
3272 long classPK = group.getClassPK();
3273
3274 String groupKey = group.getGroupKey();
3275
3276 if ((nameMap != null) &&
3277 Validator.isNotNull(nameMap.get(LocaleUtil.getDefault()))) {
3278
3279 groupKey = nameMap.get(LocaleUtil.getDefault());
3280 }
3281
3282 friendlyURL = getFriendlyURL(
3283 group.getCompanyId(), groupId, classNameId, classPK,
3284 StringPool.BLANK, friendlyURL);
3285
3286 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
3287 validateGroupKey(
3288 group.getGroupId(), group.getCompanyId(), groupKey,
3289 group.isSite());
3290 }
3291 else if (className.equals(Organization.class.getName())) {
3292 Organization organization =
3293 organizationPersistence.findByPrimaryKey(classPK);
3294
3295 groupKey = getOrgGroupName(organization.getName());
3296 }
3297 else if (!GroupConstants.USER_PERSONAL_SITE.equals(
3298 group.getGroupKey())) {
3299
3300 groupKey = String.valueOf(classPK);
3301 }
3302
3303 if (PortalUtil.isSystemGroup(group.getGroupKey()) &&
3304 !groupKey.equals(group.getGroupKey())) {
3305
3306 throw new RequiredGroupException.MustNotDeleteSystemGroup(
3307 group.getGroupId());
3308 }
3309
3310 validateFriendlyURL(
3311 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
3312 group.getClassPK(), friendlyURL);
3313
3314 validateParentGroup(group.getGroupId(), parentGroupId);
3315
3316 group.setParentGroupId(parentGroupId);
3317 group.setTreePath(group.buildTreePath());
3318 group.setGroupKey(groupKey);
3319 group.setNameMap(nameMap);
3320 group.setDescriptionMap(descriptionMap);
3321 group.setType(type);
3322 group.setManualMembership(manualMembership);
3323 group.setMembershipRestriction(membershipRestriction);
3324 group.setFriendlyURL(friendlyURL);
3325 group.setInheritContent(inheritContent);
3326 group.setActive(active);
3327
3328 if ((serviceContext != null) && group.isSite()) {
3329 group.setExpandoBridgeAttributes(serviceContext);
3330 }
3331
3332 groupPersistence.update(group);
3333
3334
3335
3336 if ((serviceContext == null) || !group.isSite()) {
3337 return group;
3338 }
3339
3340 User user = null;
3341
3342 user = userPersistence.fetchByPrimaryKey(group.getCreatorUserId());
3343
3344 if (user == null) {
3345 user = userPersistence.fetchByPrimaryKey(
3346 serviceContext.getUserId());
3347 }
3348
3349 if (user == null) {
3350 user = userLocalService.getDefaultUser(group.getCompanyId());
3351 }
3352
3353 updateAsset(
3354 user.getUserId(), group, serviceContext.getAssetCategoryIds(),
3355 serviceContext.getAssetTagNames());
3356
3357 return group;
3358 }
3359
3360
3388 @Deprecated
3389 @Override
3390 public Group updateGroup(
3391 long groupId, long parentGroupId, String name, String description,
3392 int type, boolean manualMembership, int membershipRestriction,
3393 String friendlyURL, boolean inheritContent, boolean active,
3394 ServiceContext serviceContext)
3395 throws PortalException {
3396
3397 return updateGroup(
3398 groupId, parentGroupId, getLocalizationMap(name),
3399 getLocalizationMap(description), type, manualMembership,
3400 membershipRestriction, friendlyURL, inheritContent, active,
3401 serviceContext);
3402 }
3403
3404
3414 @Override
3415 public Group updateGroup(long groupId, String typeSettings)
3416 throws PortalException {
3417
3418 Group group = groupPersistence.findByPrimaryKey(groupId);
3419
3420 UnicodeProperties oldTypeSettingsProperties =
3421 group.getTypeSettingsProperties();
3422
3423 UnicodeProperties typeSettingsProperties = new UnicodeProperties(true);
3424
3425 typeSettingsProperties.fastLoad(typeSettings);
3426
3427 String newLanguageIds = typeSettingsProperties.getProperty(
3428 PropsKeys.LOCALES);
3429
3430 if (Validator.isNotNull(newLanguageIds)) {
3431 String oldLanguageIds = oldTypeSettingsProperties.getProperty(
3432 PropsKeys.LOCALES, StringPool.BLANK);
3433
3434 String defaultLanguageId = typeSettingsProperties.getProperty(
3435 "languageId", LocaleUtil.toLanguageId(LocaleUtil.getDefault()));
3436
3437 validateLanguageIds(defaultLanguageId, newLanguageIds);
3438
3439 if (!Validator.equals(oldLanguageIds, newLanguageIds)) {
3440 LanguageUtil.resetAvailableGroupLocales(groupId);
3441 }
3442 }
3443
3444 group.setTypeSettings(typeSettings);
3445
3446 groupPersistence.update(group);
3447
3448 return group;
3449 }
3450
3451
3460 @Override
3461 public Group updateSite(long groupId, boolean site) throws PortalException {
3462 Group group = groupPersistence.findByPrimaryKey(groupId);
3463
3464 if (!group.isOrganization()) {
3465 return group;
3466 }
3467
3468 group.setSite(site);
3469
3470 groupPersistence.update(group);
3471
3472 return group;
3473 }
3474
3475 protected void addControlPanelLayouts(Group group) throws PortalException {
3476 long defaultUserId = userLocalService.getDefaultUserId(
3477 group.getCompanyId());
3478
3479 String friendlyURL = getFriendlyURL(
3480 PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
3481
3482 ServiceContext serviceContext = new ServiceContext();
3483
3484 serviceContext.setAttribute(
3485 "layout.instanceable.allowed", Boolean.TRUE);
3486
3487 layoutLocalService.addLayout(
3488 defaultUserId, group.getGroupId(), true,
3489 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
3490 PropsValues.CONTROL_PANEL_LAYOUT_NAME, StringPool.BLANK,
3491 StringPool.BLANK, LayoutConstants.TYPE_CONTROL_PANEL, false,
3492 friendlyURL, serviceContext);
3493 }
3494
3495 protected void addDefaultGuestPublicLayoutByProperties(Group group)
3496 throws PortalException {
3497
3498 List<Portlet> portlets = portletLocalService.getPortlets(
3499 group.getCompanyId());
3500
3501 if (portlets.isEmpty()) {
3502
3503
3504
3505 return;
3506 }
3507
3508 long defaultUserId = userLocalService.getDefaultUserId(
3509 group.getCompanyId());
3510 String friendlyURL = getFriendlyURL(
3511 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
3512
3513 ServiceContext serviceContext = new ServiceContext();
3514
3515 Layout layout = layoutLocalService.addLayout(
3516 defaultUserId, group.getGroupId(), false,
3517 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
3518 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
3519 StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL,
3520 serviceContext);
3521
3522 LayoutTypePortlet layoutTypePortlet =
3523 (LayoutTypePortlet)layout.getLayoutType();
3524
3525 layoutTypePortlet.setLayoutTemplateId(
3526 0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
3527
3528 LayoutTemplate layoutTemplate = layoutTypePortlet.getLayoutTemplate();
3529
3530 for (String columnId : layoutTemplate.getColumns()) {
3531 String keyPrefix = PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_PREFIX;
3532
3533 String portletIds = PropsUtil.get(keyPrefix.concat(columnId));
3534
3535 layoutTypePortlet.addPortletIds(
3536 0, StringUtil.split(portletIds), columnId, false);
3537 }
3538
3539 layoutLocalService.updateLayout(
3540 layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
3541 layout.getTypeSettings());
3542
3543 boolean updateLayoutSet = false;
3544
3545 LayoutSet layoutSet = layout.getLayoutSet();
3546
3547 if (Validator.isNotNull(
3548 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
3549
3550 layoutSet.setThemeId(
3551 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
3552
3553 updateLayoutSet = true;
3554 }
3555
3556 if (Validator.isNotNull(
3557 PropsValues.
3558 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
3559
3560 layoutSet.setColorSchemeId(
3561 PropsValues.
3562 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
3563
3564 updateLayoutSet = true;
3565 }
3566
3567 if (Validator.isNotNull(
3568 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
3569
3570 layoutSet.setWapThemeId(
3571 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
3572
3573 updateLayoutSet = true;
3574 }
3575
3576 if (Validator.isNotNull(
3577 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
3578
3579 layoutSet.setWapColorSchemeId(
3580 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
3581
3582 updateLayoutSet = true;
3583 }
3584
3585 if (updateLayoutSet) {
3586 layoutSetLocalService.updateLayoutSet(layoutSet);
3587 }
3588 }
3589
3590 protected void addDefaultGuestPublicLayouts(Group group)
3591 throws PortalException {
3592
3593 if (publicLARFile != null) {
3594 addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
3595 }
3596 else {
3597 addDefaultGuestPublicLayoutByProperties(group);
3598 }
3599 }
3600
3601 protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
3602 throws PortalException {
3603
3604 User defaultUser = userLocalService.getDefaultUser(
3605 group.getCompanyId());
3606
3607 Map<String, String[]> parameterMap = new HashMap<>();
3608
3609 parameterMap.put(
3610 PortletDataHandlerKeys.PERMISSIONS,
3611 new String[] {Boolean.TRUE.toString()});
3612 parameterMap.put(
3613 PortletDataHandlerKeys.PORTLET_CONFIGURATION,
3614 new String[] {Boolean.TRUE.toString()});
3615 parameterMap.put(
3616 PortletDataHandlerKeys.PORTLET_DATA,
3617 new String[] {Boolean.TRUE.toString()});
3618 parameterMap.put(
3619 PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
3620 new String[] {Boolean.TRUE.toString()});
3621
3622 Map<String, Serializable> importLayoutSettingsMap =
3623 ExportImportConfigurationSettingsMapFactory.
3624 buildImportLayoutSettingsMap(
3625 defaultUser, group.getGroupId(), false, null, parameterMap);
3626
3627 ExportImportConfiguration exportImportConfiguration =
3628 exportImportConfigurationLocalService.
3629 addDraftExportImportConfiguration(
3630 defaultUser.getUserId(),
3631 ExportImportConfigurationConstants.TYPE_IMPORT_LAYOUT,
3632 importLayoutSettingsMap);
3633
3634 exportImportLocalService.importLayouts(
3635 exportImportConfiguration, larFile);
3636 }
3637
3638 protected void addPortletDefaultData(Group group) throws PortalException {
3639 PortletDataContext portletDataContext =
3640 PortletDataContextFactoryUtil.createPreparePortletDataContext(
3641 group.getCompanyId(), group.getGroupId(), null, null);
3642
3643 List<PortletDataHandler> portletDataHandlers = getPortletDataHandlers(
3644 group);
3645
3646 for (PortletDataHandler portletDataHandler : portletDataHandlers) {
3647 try {
3648 portletDataHandler.addDefaultData(
3649 portletDataContext, portletDataHandler.getPortletId(),
3650 null);
3651 }
3652 catch (Exception e) {
3653 _log.error(
3654 "Unable to add default data for portlet " +
3655 portletDataHandler.getPortletId() + " in group " +
3656 group.getGroupId());
3657
3658 if (portletDataHandler.isRollbackOnException()) {
3659 throw new SystemException(e);
3660 }
3661 }
3662 }
3663 }
3664
3665 protected void deletePortletData(Group group) throws PortalException {
3666 PortletDataContext portletDataContext =
3667 PortletDataContextFactoryUtil.createPreparePortletDataContext(
3668 group.getCompanyId(), group.getGroupId(), null, null);
3669
3670 List<PortletDataHandler> portletDataHandlers = getPortletDataHandlers(
3671 group);
3672
3673 for (PortletDataHandler portletDataHandler : portletDataHandlers) {
3674 try {
3675 portletDataHandler.deleteData(
3676 portletDataContext, portletDataHandler.getPortletId(),
3677 null);
3678 }
3679 catch (Exception e) {
3680 _log.error(
3681 "Unable to delete data for portlet " +
3682 portletDataHandler.getPortletId() + " in group " +
3683 group.getGroupId());
3684
3685 if (portletDataHandler.isRollbackOnException()) {
3686 throw new SystemException(e);
3687 }
3688 }
3689 }
3690 }
3691
3692 protected Collection<Group> doSearch(
3693 long companyId, long[] classNameIds, long parentGroupId, String[] names,
3694 String[] descriptions, LinkedHashMap<String, Object> params,
3695 boolean andOperator) {
3696
3697 boolean parentGroupIdEquals = true;
3698
3699 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
3700 parentGroupIdEquals = false;
3701 }
3702
3703 params = new LinkedHashMap<>(params);
3704
3705 Boolean active = (Boolean)params.remove("active");
3706 List<Long> excludedGroupIds = (List<Long>)params.remove(
3707 "excludedGroupIds");
3708 List<Group> groupsTree = (List<Group>)params.remove("groupsTree");
3709 Boolean manualMembership = (Boolean)params.remove("manualMembership");
3710 Integer membershipRestriction = (Integer)params.remove(
3711 "membershipRestriction");
3712 Boolean site = (Boolean)params.remove("site");
3713 List<Integer> types = (List<Integer>)params.remove("types");
3714
3715 Collection<Group> groups = new HashSet<>();
3716
3717 Long userId = (Long)params.remove("usersGroups");
3718
3719 for (long classNameId : classNameIds) {
3720 groups.addAll(groupPersistence.findByC_C(companyId, classNameId));
3721 }
3722
3723 Iterator<Group> iterator = groups.iterator();
3724
3725 while (iterator.hasNext()) {
3726 Group group = iterator.next();
3727
3728
3729
3730 long liveGroupId = group.getLiveGroupId();
3731
3732 if (liveGroupId != 0) {
3733 iterator.remove();
3734
3735 continue;
3736 }
3737
3738
3739
3740 long groupParentGroupId = group.getParentGroupId();
3741
3742 if ((parentGroupIdEquals &&
3743 (groupParentGroupId != parentGroupId)) ||
3744 (!parentGroupIdEquals &&
3745 (groupParentGroupId == parentGroupId))) {
3746
3747 iterator.remove();
3748
3749 continue;
3750 }
3751
3752
3753
3754 String groupKey = group.getGroupKey();
3755
3756 if (groupKey.equals(GroupConstants.CONTROL_PANEL)) {
3757 iterator.remove();
3758
3759 continue;
3760 }
3761
3762 boolean containsName = matches(group.getNameCurrentValue(), names);
3763 boolean containsDescription = matches(
3764 group.getDescriptionCurrentValue(), descriptions);
3765
3766 if ((andOperator && (!containsName || !containsDescription)) ||
3767 (!andOperator && !containsName && !containsDescription)) {
3768
3769 iterator.remove();
3770
3771 continue;
3772 }
3773
3774
3775
3776 if (active != null) {
3777 if (active != group.isActive()) {
3778 iterator.remove();
3779
3780 continue;
3781 }
3782 }
3783
3784
3785
3786 if ((excludedGroupIds != null) &&
3787 excludedGroupIds.contains(group.getGroupId())) {
3788
3789 iterator.remove();
3790
3791 continue;
3792 }
3793
3794
3795
3796 if (groupsTree != null) {
3797 String treePath = group.getTreePath();
3798
3799 boolean matched = false;
3800
3801 for (Group groupTree : groupsTree) {
3802 String groupTreePath = StringUtil.quote(
3803 String.valueOf(groupTree.getGroupId()),
3804 StringPool.SLASH);
3805
3806 if (treePath.contains(groupTreePath)) {
3807 matched = true;
3808
3809 break;
3810 }
3811 }
3812
3813 if (!matched) {
3814 iterator.remove();
3815
3816 continue;
3817 }
3818 }
3819
3820
3821
3822 if ((manualMembership != null) &&
3823 (manualMembership != group.isManualMembership())) {
3824
3825 iterator.remove();
3826
3827 continue;
3828 }
3829
3830
3831
3832 if ((membershipRestriction != null) &&
3833 (membershipRestriction != group.getMembershipRestriction())) {
3834
3835 iterator.remove();
3836
3837 continue;
3838 }
3839
3840
3841
3842 if (site != null) {
3843 if (site != group.isSite()) {
3844 iterator.remove();
3845
3846 continue;
3847 }
3848 }
3849
3850
3851
3852 int type = group.getType();
3853
3854 if (type == 4) {
3855 iterator.remove();
3856
3857 continue;
3858 }
3859
3860 if ((types != null) && !types.contains(type)) {
3861 iterator.remove();
3862
3863 continue;
3864 }
3865 }
3866
3867
3868
3869 RolePermissions rolePermissions = (RolePermissions)params.remove(
3870 "rolePermissions");
3871
3872 if (rolePermissions != null) {
3873 ResourceAction resourceAction =
3874 resourceActionLocalService.fetchResourceAction(
3875 rolePermissions.getName(), rolePermissions.getActionId());
3876
3877 if (resourceAction != null) {
3878 Set<Group> rolePermissionsGroups = new HashSet<>();
3879
3880 if (resourceBlockLocalService.isSupported(
3881 rolePermissions.getName())) {
3882
3883 List<ResourceTypePermission> resourceTypePermissions =
3884 resourceTypePermissionPersistence.findByRoleId(
3885 rolePermissions.getRoleId());
3886
3887 for (ResourceTypePermission resourceTypePermission :
3888 resourceTypePermissions) {
3889
3890 if ((resourceTypePermission.getCompanyId() ==
3891 companyId) &&
3892 Validator.equals(
3893 rolePermissions.getName(),
3894 resourceTypePermission.getName()) &&
3895 resourceTypePermission.hasAction(resourceAction)) {
3896
3897 Group group = groupPersistence.fetchByPrimaryKey(
3898 resourceTypePermission.getGroupId());
3899
3900 if (group != null) {
3901 rolePermissionsGroups.add(group);
3902 }
3903 }
3904 }
3905 }
3906 else {
3907 List<ResourcePermission> resourcePermissions =
3908 resourcePermissionPersistence.findByC_N_S(
3909 companyId, rolePermissions.getName(),
3910 rolePermissions.getScope());
3911
3912 for (ResourcePermission resourcePermission :
3913 resourcePermissions) {
3914
3915 if ((resourcePermission.getRoleId() ==
3916 rolePermissions.getRoleId()) &&
3917 resourcePermission.hasAction(
3918 resourceAction)) {
3919
3920 Group group = groupPersistence.fetchByPrimaryKey(
3921 GetterUtil.getLong(
3922 resourcePermission.getPrimKey()));
3923
3924 if (group != null) {
3925 rolePermissionsGroups.add(group);
3926 }
3927 }
3928 }
3929 }
3930
3931 groups.retainAll(rolePermissionsGroups);
3932 }
3933 }
3934
3935
3936
3937 Long roleId = (Long)params.remove("groupsRoles");
3938
3939 if (roleId != null) {
3940 groups.retainAll(rolePersistence.getGroups(roleId));
3941 }
3942
3943 if (userId == null) {
3944 return groups;
3945 }
3946
3947
3948
3949 Set<Group> joinedGroups = new HashSet<>(
3950 userPersistence.getGroups(userId));
3951
3952 boolean inherit = GetterUtil.getBoolean(params.remove("inherit"), true);
3953
3954 if (inherit) {
3955
3956
3957
3958 long[] organizationIds = userPersistence.getOrganizationPrimaryKeys(
3959 userId);
3960
3961 for (long organizationId : organizationIds) {
3962 for (Group group : groups) {
3963 if (organizationId == group.getClassPK()) {
3964 joinedGroups.add(group);
3965 }
3966 }
3967 }
3968
3969
3970
3971 for (long organizationId : organizationIds) {
3972 joinedGroups.addAll(
3973 organizationPersistence.getGroups(organizationId));
3974 }
3975
3976
3977
3978 long[] userGroupIds = userPersistence.getUserGroupPrimaryKeys(
3979 userId);
3980
3981 for (long userGroupId : userGroupIds) {
3982 joinedGroups.addAll(
3983 userGroupPersistence.getGroups(userGroupId));
3984 }
3985 }
3986
3987 if (_log.isDebugEnabled() && !params.isEmpty()) {
3988 _log.debug("Unprocessed parameters " + MapUtil.toString(params));
3989 }
3990
3991 if (joinedGroups.size() > groups.size()) {
3992 groups.retainAll(joinedGroups);
3993
3994 return groups;
3995 }
3996 else {
3997 joinedGroups.retainAll(groups);
3998
3999 return joinedGroups;
4000 }
4001 }
4002
4003 protected long[] getClassNameIds() {
4004 if (_classNameIds == null) {
4005 _classNameIds = new long[] {
4006 classNameLocalService.getClassNameId(Group.class),
4007 classNameLocalService.getClassNameId(Organization.class)
4008 };
4009 }
4010
4011 return _classNameIds;
4012 }
4013
4014 protected String getFriendlyURL(
4015 long companyId, long groupId, long classNameId, long classPK,
4016 String friendlyName, String friendlyURL)
4017 throws PortalException {
4018
4019 friendlyURL = getFriendlyURL(friendlyURL);
4020
4021 if (Validator.isNotNull(friendlyURL)) {
4022 return friendlyURL;
4023 }
4024
4025 friendlyURL = StringPool.SLASH + getFriendlyURL(friendlyName);
4026
4027 String originalFriendlyURL = friendlyURL;
4028
4029 for (int i = 1;; i++) {
4030 try {
4031 validateFriendlyURL(
4032 companyId, groupId, classNameId, classPK, friendlyURL);
4033
4034 break;
4035 }
4036 catch (GroupFriendlyURLException gfurle) {
4037 int type = gfurle.getType();
4038
4039 if (type == GroupFriendlyURLException.DUPLICATE) {
4040 friendlyURL = originalFriendlyURL + i;
4041 }
4042 else {
4043 friendlyURL = StringPool.SLASH + classPK;
4044
4045 break;
4046 }
4047 }
4048 }
4049
4050 return friendlyURL;
4051 }
4052
4053 protected String getFriendlyURL(String friendlyURL) {
4054 return FriendlyURLNormalizerUtil.normalize(friendlyURL);
4055 }
4056
4057 protected String getOrgGroupName(String name) {
4058 return name + ORGANIZATION_NAME_SUFFIX;
4059 }
4060
4061 protected List<PortletDataHandler> getPortletDataHandlers(Group group) {
4062 List<Portlet> portlets = portletLocalService.getPortlets(
4063 group.getCompanyId());
4064
4065 List<PortletDataHandler> portletDataHandlers = new ArrayList<>(
4066 portlets.size());
4067
4068 for (Portlet portlet : portlets) {
4069 if (!portlet.isActive()) {
4070 continue;
4071 }
4072
4073 PortletDataHandler portletDataHandler =
4074 portlet.getPortletDataHandlerInstance();
4075
4076 if ((portletDataHandler != null) &&
4077 !portletDataHandler.isDataPortalLevel()) {
4078
4079 portletDataHandlers.add(portletDataHandler);
4080 }
4081 }
4082
4083 return portletDataHandlers;
4084 }
4085
4086 protected String[] getSearchNames(long companyId, String name) {
4087 if (Validator.isNull(name)) {
4088 return new String[] {null};
4089 }
4090
4091 Company company = companyPersistence.fetchByPrimaryKey(companyId);
4092
4093 if (company == null) {
4094 return CustomSQLUtil.keywords(name);
4095 }
4096
4097 Account account = accountPersistence.fetchByPrimaryKey(
4098 company.getAccountId());
4099
4100 if (account == null) {
4101 return CustomSQLUtil.keywords(name);
4102 }
4103
4104 String companyName = account.getName();
4105
4106 if (StringUtil.wildcardMatches(
4107 companyName, name, CharPool.UNDERLINE, CharPool.PERCENT,
4108 CharPool.BACK_SLASH, false)) {
4109
4110 String[] searchNames = CustomSQLUtil.keywords(name);
4111
4112 String guestName = StringUtil.quote(
4113 StringUtil.toLowerCase(GroupConstants.GUEST),
4114 StringPool.PERCENT);
4115
4116 return ArrayUtil.append(searchNames, guestName);
4117 }
4118
4119 return CustomSQLUtil.keywords(name);
4120 }
4121
4122 protected void initImportLARFile() {
4123 String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
4124
4125 if (_log.isDebugEnabled()) {
4126 _log.debug("Reading public LAR file " + publicLARFileName);
4127 }
4128
4129 if (Validator.isNotNull(publicLARFileName)) {
4130 publicLARFile = new File(publicLARFileName);
4131
4132 if (!publicLARFile.exists()) {
4133 _log.error(
4134 "Public LAR file " + publicLARFile + " does not exist");
4135
4136 publicLARFile = null;
4137 }
4138 else {
4139 if (_log.isDebugEnabled()) {
4140 _log.debug("Using public LAR file " + publicLARFileName);
4141 }
4142 }
4143 }
4144 }
4145
4146 protected void initUserPersonalSitePermissions(Group group)
4147 throws PortalException {
4148
4149
4150
4151 Role role = roleLocalService.getRole(
4152 group.getCompanyId(), RoleConstants.USER);
4153
4154 setRolePermissions(
4155 group, role, Layout.class.getName(),
4156 new String[] {ActionKeys.VIEW});
4157
4158 setRolePermissions(
4159 group, role, "com.liferay.portlet.blogs",
4160 new String[] {
4161 ActionKeys.ADD_ENTRY, ActionKeys.PERMISSIONS,
4162 ActionKeys.SUBSCRIBE
4163 });
4164
4165
4166
4167 role = roleLocalService.getRole(
4168 group.getCompanyId(), RoleConstants.POWER_USER);
4169
4170 List<Portlet> portlets = portletLocalService.getPortlets(
4171 group.getCompanyId(), false, false);
4172
4173 for (Portlet portlet : portlets) {
4174 List<String> actions =
4175 ResourceActionsUtil.getPortletResourceActions(
4176 portlet.getPortletId());
4177
4178 String controlPanelEntryCategory = GetterUtil.getString(
4179 portlet.getControlPanelEntryCategory());
4180
4181 if (actions.contains(ActionKeys.ACCESS_IN_CONTROL_PANEL) &&
4182 controlPanelEntryCategory.startsWith(
4183 PortletCategoryKeys.SITE_ADMINISTRATION)) {
4184
4185 setRolePermissions(
4186 group, role, portlet.getPortletId(),
4187 new String[] {ActionKeys.ACCESS_IN_CONTROL_PANEL});
4188 }
4189 }
4190
4191 setRolePermissions(
4192 group, role, Group.class.getName(),
4193 new String[] {
4194 ActionKeys.MANAGE_LAYOUTS, ActionKeys.VIEW_SITE_ADMINISTRATION
4195 });
4196
4197 setRolePermissions(group, role, "com.liferay.portlet.asset");
4198 setRolePermissions(group, role, "com.liferay.portlet.blogs");
4199 setRolePermissions(group, role, "com.liferay.portlet.bookmarks");
4200 setRolePermissions(group, role, "com.liferay.portlet.documentlibrary");
4201 setRolePermissions(group, role, "com.liferay.portlet.imagegallery");
4202 setRolePermissions(group, role, "com.liferay.portlet.journal");
4203 setRolePermissions(group, role, "com.liferay.portlet.messageboards");
4204 setRolePermissions(group, role, "com.liferay.portlet.wiki");
4205 }
4206
4207 protected boolean isParentGroup(long parentGroupId, long groupId)
4208 throws PortalException {
4209
4210
4211
4212 if (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4213 return false;
4214 }
4215
4216 Group group = groupPersistence.findByPrimaryKey(groupId);
4217
4218 String treePath = group.getTreePath();
4219
4220 if (treePath.contains(
4221 StringPool.SLASH + parentGroupId + StringPool.SLASH)) {
4222
4223 return true;
4224 }
4225 else {
4226 return false;
4227 }
4228 }
4229
4230 protected boolean isStaging(ServiceContext serviceContext) {
4231 if (serviceContext != null) {
4232 return ParamUtil.getBoolean(serviceContext, "staging");
4233 }
4234
4235 return false;
4236 }
4237
4238 protected boolean isUseComplexSQL(long[] classNameIds) {
4239 if (ArrayUtil.isEmpty(classNameIds)) {
4240 return true;
4241 }
4242
4243 if (_complexSQLClassNameIds == null) {
4244 String[] complexSQLClassNames =
4245 PropsValues.GROUPS_COMPLEX_SQL_CLASS_NAMES;
4246
4247 long[] complexSQLClassNameIds =
4248 new long[complexSQLClassNames.length];
4249
4250 for (int i = 0; i < complexSQLClassNames.length; i++) {
4251 String complexSQLClassName = complexSQLClassNames[i];
4252
4253 complexSQLClassNameIds[i] =
4254 classNameLocalService.getClassNameId(complexSQLClassName);
4255 }
4256
4257 _complexSQLClassNameIds = complexSQLClassNameIds;
4258 }
4259
4260 for (long classNameId : classNameIds) {
4261 if (ArrayUtil.contains(_complexSQLClassNameIds, classNameId)) {
4262 return true;
4263 }
4264 }
4265
4266 return false;
4267 }
4268
4269 protected boolean matches(String s, String[] keywords) {
4270 if ((keywords == null) ||
4271 ((keywords.length == 1) && (keywords[0] == null))) {
4272
4273 return true;
4274 }
4275
4276 for (String keyword : keywords) {
4277 if (StringUtil.wildcardMatches(
4278 s, keyword, CharPool.UNDERLINE, CharPool.PERCENT,
4279 CharPool.BACK_SLASH, false)) {
4280
4281 return true;
4282 }
4283 }
4284
4285 return false;
4286 }
4287
4288 protected void setCompanyPermissions(
4289 Role role, String name, String[] actionIds)
4290 throws PortalException {
4291
4292 if (resourceBlockLocalService.isSupported(name)) {
4293 resourceBlockLocalService.setCompanyScopePermissions(
4294 role.getCompanyId(), name, role.getRoleId(),
4295 Arrays.asList(actionIds));
4296 }
4297 else {
4298 resourcePermissionLocalService.setResourcePermissions(
4299 role.getCompanyId(), name, ResourceConstants.SCOPE_COMPANY,
4300 String.valueOf(role.getCompanyId()), role.getRoleId(),
4301 actionIds);
4302 }
4303 }
4304
4305 protected void setRolePermissions(Group group, Role role, String name)
4306 throws PortalException {
4307
4308 List<String> actions = ResourceActionsUtil.getModelResourceActions(
4309 name);
4310
4311 setRolePermissions(
4312 group, role, name, actions.toArray(new String[actions.size()]));
4313 }
4314
4315 protected void setRolePermissions(
4316 Group group, Role role, String name, String[] actionIds)
4317 throws PortalException {
4318
4319 if (resourceBlockLocalService.isSupported(name)) {
4320 resourceBlockLocalService.setGroupScopePermissions(
4321 role.getCompanyId(), group.getGroupId(), name, role.getRoleId(),
4322 Arrays.asList(actionIds));
4323 }
4324 else {
4325 resourcePermissionLocalService.setResourcePermissions(
4326 group.getCompanyId(), name, ResourceConstants.SCOPE_GROUP,
4327 String.valueOf(group.getGroupId()), role.getRoleId(),
4328 actionIds);
4329 }
4330 }
4331
4332 protected List<Group> sort(
4333 Collection<Group> groups, int start, int end,
4334 OrderByComparator<Group> obc) {
4335
4336 if (obc == null) {
4337 obc = new GroupNameComparator(true);
4338 }
4339
4340 List<Group> groupList = null;
4341
4342 if (groups instanceof List) {
4343 groupList = (List<Group>)groups;
4344 }
4345 else {
4346 groupList = new ArrayList<>(groups);
4347 }
4348
4349 Collections.sort(groupList, obc);
4350
4351 return Collections.unmodifiableList(
4352 ListUtil.subList(groupList, start, end));
4353 }
4354
4355 protected void unscheduleStaging(Group group) {
4356 try {
4357
4358
4359
4360 String groupName = StagingUtil.getSchedulerGroupName(
4361 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
4362
4363 SchedulerEngineHelperUtil.delete(groupName, StorageType.PERSISTED);
4364
4365 long liveGroupId = 0;
4366 long stagingGroupId = 0;
4367
4368 if (group.isStagingGroup()) {
4369 liveGroupId = group.getLiveGroupId();
4370
4371 stagingGroupId = group.getGroupId();
4372 }
4373 else if (group.hasStagingGroup()) {
4374 liveGroupId = group.getGroupId();
4375
4376 stagingGroupId = group.getStagingGroup().getGroupId();
4377 }
4378
4379 if ((liveGroupId != 0) && (stagingGroupId != 0)) {
4380
4381
4382
4383 groupName = StagingUtil.getSchedulerGroupName(
4384 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
4385
4386 SchedulerEngineHelperUtil.delete(
4387 groupName, StorageType.PERSISTED);
4388
4389
4390
4391 groupName = StagingUtil.getSchedulerGroupName(
4392 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
4393
4394 SchedulerEngineHelperUtil.delete(
4395 groupName, StorageType.PERSISTED);
4396 }
4397 }
4398 catch (Exception e) {
4399 _log.error(
4400 "Unable to unschedule events for group: " + group.getGroupId());
4401 }
4402 }
4403
4404 protected void validateFriendlyURL(
4405 long companyId, long groupId, long classNameId, long classPK,
4406 String friendlyURL)
4407 throws PortalException {
4408
4409 Company company = companyPersistence.findByPrimaryKey(companyId);
4410
4411 if (company.isSystem()) {
4412 return;
4413 }
4414
4415 if (Validator.isNull(friendlyURL)) {
4416 return;
4417 }
4418
4419 int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
4420
4421 if (exceptionType != -1) {
4422 throw new GroupFriendlyURLException(exceptionType);
4423 }
4424
4425 Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
4426
4427 if ((group != null) && (group.getGroupId() != groupId)) {
4428 GroupFriendlyURLException gfurle = new GroupFriendlyURLException(
4429 GroupFriendlyURLException.DUPLICATE);
4430
4431 gfurle.setDuplicateClassPK(group.getGroupId());
4432 gfurle.setDuplicateClassName(Group.class.getName());
4433
4434 throw gfurle;
4435 }
4436
4437 String groupIdFriendlyURL = friendlyURL.substring(1);
4438
4439 if (Validator.isNumber(groupIdFriendlyURL)) {
4440 long groupClassNameId = classNameLocalService.getClassNameId(
4441 Group.class);
4442
4443 if (((classNameId != groupClassNameId) &&
4444 !groupIdFriendlyURL.equals(String.valueOf(classPK)) &&
4445 !PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC) ||
4446 ((classNameId == groupClassNameId) &&
4447 !groupIdFriendlyURL.equals(String.valueOf(groupId)))) {
4448
4449 GroupFriendlyURLException gfurle =
4450 new GroupFriendlyURLException(
4451 GroupFriendlyURLException.POSSIBLE_DUPLICATE);
4452
4453 gfurle.setKeywordConflict(groupIdFriendlyURL);
4454
4455 throw gfurle;
4456 }
4457 }
4458
4459 String screenName = friendlyURL.substring(1);
4460
4461 User user = userPersistence.fetchByC_SN(companyId, screenName);
4462
4463 if (user != null) {
4464 long userClassNameId = classNameLocalService.getClassNameId(
4465 User.class);
4466
4467 if ((classNameId == userClassNameId) &&
4468 (classPK == user.getUserId())) {
4469 }
4470 else {
4471 GroupFriendlyURLException gfurle =
4472 new GroupFriendlyURLException(
4473 GroupFriendlyURLException.DUPLICATE);
4474
4475 gfurle.setDuplicateClassPK(user.getUserId());
4476 gfurle.setDuplicateClassName(User.class.getName());
4477
4478 throw gfurle;
4479 }
4480 }
4481
4482 if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
4483 throw new GroupFriendlyURLException(
4484 GroupFriendlyURLException.TOO_DEEP);
4485 }
4486 }
4487
4488 protected void validateGroupKey(
4489 long groupId, long companyId, String groupKey, boolean site)
4490 throws PortalException {
4491
4492 if (Validator.isNull(groupKey) || Validator.isNumber(groupKey) ||
4493 groupKey.contains(StringPool.STAR) ||
4494 groupKey.contains(ORGANIZATION_NAME_SUFFIX)) {
4495
4496 throw new GroupKeyException();
4497 }
4498
4499 try {
4500 Group group = groupFinder.findByC_GK(companyId, groupKey);
4501
4502 if ((groupId <= 0) || (group.getGroupId() != groupId)) {
4503 throw new DuplicateGroupException("{groupId=" + groupId + "}");
4504 }
4505 }
4506 catch (NoSuchGroupException nsge) {
4507 }
4508
4509 if (site) {
4510 Company company = companyLocalService.getCompany(companyId);
4511
4512 if (groupKey.equals(company.getName())) {
4513 throw new DuplicateGroupException();
4514 }
4515 }
4516 }
4517
4518 protected void validateInheritContent(
4519 long parentGroupId, boolean inheritContent)
4520 throws GroupInheritContentException {
4521
4522 if (!inheritContent) {
4523 return;
4524 }
4525
4526 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4527 throw new GroupInheritContentException();
4528 }
4529
4530 Group parentGroup = groupPersistence.fetchByPrimaryKey(parentGroupId);
4531
4532 if (parentGroup.isInheritContent()) {
4533 throw new GroupInheritContentException();
4534 }
4535 }
4536
4537 protected void validateLanguageIds(
4538 String defaultLanguageId, String languageIds)
4539 throws PortalException {
4540
4541 String[] languageIdsArray = StringUtil.split(languageIds);
4542
4543 for (String languageId : languageIdsArray) {
4544 if (!LanguageUtil.isAvailableLocale(
4545 LocaleUtil.fromLanguageId(languageId))) {
4546
4547 LocaleException le = new LocaleException(
4548 LocaleException.TYPE_DISPLAY_SETTINGS);
4549
4550 le.setSourceAvailableLocales(
4551 LanguageUtil.getAvailableLocales());
4552 le.setTargetAvailableLocales(
4553 Arrays.asList(
4554 LocaleUtil.fromLanguageIds(languageIdsArray)));
4555
4556 throw le;
4557 }
4558 }
4559
4560 if (!ArrayUtil.contains(languageIdsArray, defaultLanguageId)) {
4561 LocaleException le = new LocaleException(
4562 LocaleException.TYPE_DEFAULT);
4563
4564 le.setSourceAvailableLocales(LanguageUtil.getAvailableLocales());
4565 le.setTargetAvailableLocales(
4566 Arrays.asList(LocaleUtil.fromLanguageIds(languageIdsArray)));
4567
4568 throw le;
4569 }
4570 }
4571
4572 protected void validateParentGroup(long groupId, long parentGroupId)
4573 throws PortalException {
4574
4575 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4576 return;
4577 }
4578
4579 if (groupId == parentGroupId) {
4580 throw new GroupParentException.MustNotBeOwnParent(groupId);
4581 }
4582
4583 Group group = groupPersistence.fetchByPrimaryKey(groupId);
4584
4585 if (group == null) {
4586 return;
4587 }
4588
4589 if ((groupId > 0) &&
4590 (parentGroupId != GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
4591
4592
4593
4594 if (isParentGroup(groupId, parentGroupId)) {
4595 throw new GroupParentException.MustNotHaveChildParent(
4596 groupId, parentGroupId);
4597 }
4598 }
4599
4600 Group parentGroup = groupPersistence.findByPrimaryKey(parentGroupId);
4601
4602 if (group.isStagingGroup()) {
4603 long stagingGroupId = parentGroup.getStagingGroup().getGroupId();
4604
4605 if (groupId == stagingGroupId) {
4606 throw new GroupParentException.MustNotHaveStagingParent(
4607 groupId, stagingGroupId);
4608 }
4609 }
4610 }
4611
4612 protected File publicLARFile;
4613
4614 private static final Log _log = LogFactoryUtil.getLog(
4615 GroupLocalServiceImpl.class);
4616
4617 private volatile long[] _classNameIds;
4618 private volatile long[] _complexSQLClassNameIds;
4619 private final Map<String, Group> _systemGroupsMap = new HashMap<>();
4620
4621 }