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.thread.local.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
455 @Deprecated
456 @Override
457 public Group addGroup(
458 long userId, long parentGroupId, String className, long classPK,
459 long liveGroupId, String name, String description, int type,
460 boolean manualMembership, int membershipRestriction,
461 String friendlyURL, boolean site, boolean active,
462 ServiceContext serviceContext)
463 throws PortalException {
464
465 return addGroup(
466 userId, parentGroupId, className, classPK, liveGroupId,
467 getLocalizationMap(name), getLocalizationMap(description), type,
468 manualMembership, membershipRestriction, friendlyURL, site, false,
469 active, serviceContext);
470 }
471
472
496 @Deprecated
497 @Override
498 public Group addGroup(
499 long userId, long parentGroupId, String className, long classPK,
500 String name, String description, int type, String friendlyURL,
501 boolean site, boolean active, ServiceContext serviceContext)
502 throws PortalException {
503
504 return addGroup(
505 userId, parentGroupId, className, classPK,
506 GroupConstants.DEFAULT_LIVE_GROUP_ID, getLocalizationMap(name),
507 getLocalizationMap(description), type, true,
508 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
509 active, serviceContext);
510 }
511
512
537 @Deprecated
538 @Override
539 public Group addGroup(
540 long userId, String className, long classPK, long liveGroupId,
541 String name, String description, int type, String friendlyURL,
542 boolean site, boolean active, ServiceContext serviceContext)
543 throws PortalException {
544
545 return addGroup(
546 userId, GroupConstants.DEFAULT_PARENT_GROUP_ID, className, classPK,
547 liveGroupId, getLocalizationMap(name),
548 getLocalizationMap(description), type, true,
549 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
550 active, serviceContext);
551 }
552
553
576 @Deprecated
577 @Override
578 public Group addGroup(
579 long userId, String className, long classPK, String name,
580 String description, int type, String friendlyURL, boolean site,
581 boolean active, ServiceContext serviceContext)
582 throws PortalException {
583
584 return addGroup(
585 userId, GroupConstants.DEFAULT_PARENT_GROUP_ID, className, classPK,
586 GroupConstants.DEFAULT_LIVE_GROUP_ID, getLocalizationMap(name),
587 getLocalizationMap(description), type, true,
588 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
589 active, serviceContext);
590 }
591
592
598 @Override
599 public void addRoleGroups(long roleId, long[] groupIds) {
600 rolePersistence.addGroups(roleId, groupIds);
601
602 PermissionCacheUtil.clearCache();
603 }
604
605
611 @Override
612 public void addUserGroups(long userId, long[] groupIds) {
613 userPersistence.addGroups(userId, groupIds);
614
615 PermissionCacheUtil.clearCache(userId);
616 }
617
618
625 @Override
626 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
627 public void checkCompanyGroup(long companyId) throws PortalException {
628 long classNameId = classNameLocalService.getClassNameId(Company.class);
629
630 int count = groupPersistence.countByC_C_C(
631 companyId, classNameId, companyId);
632
633 if (count == 0) {
634 long defaultUserId = userLocalService.getDefaultUserId(companyId);
635
636 groupLocalService.addGroup(
637 defaultUserId, GroupConstants.DEFAULT_PARENT_GROUP_ID,
638 Company.class.getName(), companyId,
639 GroupConstants.DEFAULT_LIVE_GROUP_ID,
640 getLocalizationMap(GroupConstants.GLOBAL), null, 0, true,
641 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION,
642 GroupConstants.GLOBAL_FRIENDLY_URL, true, true, null);
643 }
644 }
645
646
654 @Override
655 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
656 public void checkSystemGroups(long companyId) throws PortalException {
657 String companyIdHexString = StringUtil.toHexString(companyId);
658
659 for (Group group : groupFinder.findBySystem(companyId)) {
660 _systemGroupsMap.put(
661 companyIdHexString.concat(group.getGroupKey()), group);
662 }
663
664 long defaultUserId = userLocalService.getDefaultUserId(companyId);
665
666 String[] systemGroups = PortalUtil.getSystemGroups();
667
668 for (String groupKey : systemGroups) {
669 String groupCacheKey = companyIdHexString.concat(groupKey);
670
671 Group group = _systemGroupsMap.get(groupCacheKey);
672
673 if (group == null) {
674 group = groupPersistence.fetchByC_GK(companyId, groupKey);
675 }
676
677 if (group == null) {
678 String className = null;
679 long classPK = 0;
680 int type = GroupConstants.TYPE_SITE_OPEN;
681 String friendlyURL = null;
682 boolean site = true;
683
684 if (groupKey.equals(GroupConstants.CONTROL_PANEL)) {
685 type = GroupConstants.TYPE_SITE_PRIVATE;
686 friendlyURL = GroupConstants.CONTROL_PANEL_FRIENDLY_URL;
687 site = false;
688 }
689 else if (groupKey.equals(GroupConstants.GUEST)) {
690 friendlyURL = "/guest";
691 }
692 else if (groupKey.equals(GroupConstants.USER_PERSONAL_SITE)) {
693 className = UserPersonalSite.class.getName();
694 classPK = defaultUserId;
695 type = GroupConstants.TYPE_SITE_PRIVATE;
696 friendlyURL =
697 GroupConstants.USER_PERSONAL_SITE_FRIENDLY_URL;
698 site = false;
699 }
700
701 group = groupLocalService.addGroup(
702 defaultUserId, GroupConstants.DEFAULT_PARENT_GROUP_ID,
703 className, classPK, GroupConstants.DEFAULT_LIVE_GROUP_ID,
704 getLocalizationMap(groupKey), null, type, true,
705 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL,
706 site, true, null);
707
708 if (groupKey.equals(GroupConstants.USER_PERSONAL_SITE)) {
709 initUserPersonalSitePermissions(group);
710 }
711 }
712
713 if (group.isControlPanel()) {
714 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
715 group.getGroupId(), true);
716
717 if (layoutSet.getPageCount() == 0) {
718 addControlPanelLayouts(group);
719 }
720 }
721
722 if (group.isGuest()) {
723 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
724 group.getGroupId(), false);
725
726 if (layoutSet.getPageCount() == 0) {
727 addDefaultGuestPublicLayouts(group);
728 }
729 }
730
731 _systemGroupsMap.put(groupCacheKey, group);
732 }
733 }
734
735
749 @Override
750 public Group deleteGroup(Group group) throws PortalException {
751 boolean deleteInProcess = GroupThreadLocal.isDeleteInProcess();
752
753 try {
754 GroupThreadLocal.setDeleteInProcess(true);
755
756 if (((group.isCompany() && !group.isCompanyStagingGroup()) ||
757 PortalUtil.isSystemGroup(group.getGroupKey())) &&
758 !CompanyThreadLocal.isDeleteInProcess()) {
759
760 throw new RequiredGroupException.MustNotDeleteSystemGroup(
761 group.getGroupId());
762 }
763
764 if (groupPersistence.countByC_P_S(
765 group.getCompanyId(), group.getGroupId(), true) > 0) {
766
767 throw new RequiredGroupException.MustNotDeleteGroupThatHasChild(
768 group.getGroupId());
769 }
770
771 List<BackgroundTask> backgroundTasks =
772 BackgroundTaskManagerUtil.getBackgroundTasks(
773 group.getGroupId(),
774 BackgroundTaskConstants.STATUS_IN_PROGRESS);
775
776 if (!backgroundTasks.isEmpty()) {
777 throw new PendingBackgroundTaskException(
778 "Unable to delete group with pending background tasks");
779 }
780
781
782
783 BackgroundTaskManagerUtil.deleteGroupBackgroundTasks(
784 group.getGroupId());
785
786
787
788 layoutSetBranchLocalService.deleteLayoutSetBranches(
789 group.getGroupId(), true, true);
790
791 layoutSetBranchLocalService.deleteLayoutSetBranches(
792 group.getGroupId(), false, true);
793
794
795
796 ServiceContext serviceContext = new ServiceContext();
797
798 try {
799 layoutSetLocalService.deleteLayoutSet(
800 group.getGroupId(), true, serviceContext);
801 }
802 catch (NoSuchLayoutSetException nslse) {
803 }
804
805 try {
806 layoutSetLocalService.deleteLayoutSet(
807 group.getGroupId(), false, serviceContext);
808 }
809 catch (NoSuchLayoutSetException nslse) {
810 }
811
812
813
814 membershipRequestLocalService.deleteMembershipRequests(
815 group.getGroupId());
816
817
818
819 portletPreferencesLocalService.deletePortletPreferences(
820 group.getGroupId(), PortletKeys.PREFS_OWNER_TYPE_GROUP,
821 PortletKeys.PREFS_PLID_SHARED);
822
823
824
825 dlAppLocalService.deleteAllRepositories(group.getGroupId());
826
827
828
829 teamLocalService.deleteTeams(group.getGroupId());
830
831
832
833 exportImportConfigurationLocalService.
834 deleteExportImportConfigurations(group.getGroupId());
835
836 unscheduleStaging(group);
837
838 if (group.hasStagingGroup()) {
839 try {
840 stagingLocalService.disableStaging(group, serviceContext);
841 }
842 catch (Exception e) {
843 _log.error(
844 "Unable to disable staging for group " +
845 group.getGroupId());
846 }
847 }
848
849
850
851 ThemeLoader themeLoader =
852 ThemeLoaderFactory.getDefaultThemeLoader();
853
854 if (themeLoader != null) {
855 String themePath =
856 themeLoader.getFileStorage() + StringPool.SLASH +
857 group.getGroupId();
858
859 FileUtil.deltree(themePath + "-private");
860 FileUtil.deltree(themePath + "-public");
861 }
862
863
864
865 deletePortletData(group);
866
867
868
869 if (group.isRegularSite()) {
870 assetEntryLocalService.deleteEntry(
871 Group.class.getName(), group.getGroupId());
872 }
873
874 assetEntryLocalService.deleteGroupEntries(group.getGroupId());
875
876 assetTagLocalService.deleteGroupTags(group.getGroupId());
877
878 assetVocabularyLocalService.deleteVocabularies(group.getGroupId());
879
880
881
882 expandoRowLocalService.deleteRows(group.getGroupId());
883
884
885
886 socialActivityLocalService.deleteActivities(group.getGroupId());
887 socialActivitySettingLocalService.deleteActivitySettings(
888 group.getGroupId());
889 socialRequestLocalService.deleteRequests(
890 classNameLocalService.getClassNameId(Group.class),
891 group.getGroupId());
892
893
894
895 List<ResourcePermission> resourcePermissions =
896 resourcePermissionPersistence.findByC_LikeP(
897 group.getCompanyId(), String.valueOf(group.getGroupId()));
898
899 for (ResourcePermission resourcePermission : resourcePermissions) {
900 resourcePermissionLocalService.deleteResourcePermission(
901 resourcePermission);
902 }
903
904 if (!group.isStagingGroup() &&
905 (group.isOrganization() || group.isRegularSite())) {
906
907 resourceLocalService.deleteResource(
908 group.getCompanyId(), Group.class.getName(),
909 ResourceConstants.SCOPE_INDIVIDUAL, group.getGroupId());
910 }
911
912
913
914 trashEntryLocalService.deleteEntries(group.getGroupId());
915
916
917
918 List<WorkflowHandler<?>> scopeableWorkflowHandlers =
919 WorkflowHandlerRegistryUtil.getScopeableWorkflowHandlers();
920
921 for (WorkflowHandler<?> scopeableWorkflowHandler :
922 scopeableWorkflowHandlers) {
923
924 if (!scopeableWorkflowHandler.isVisible()) {
925 continue;
926 }
927
928 WorkflowDefinitionLink workflowDefinitionLink =
929 workflowDefinitionLinkLocalService.
930 fetchWorkflowDefinitionLink(
931 group.getCompanyId(), group.getGroupId(),
932 scopeableWorkflowHandler.getClassName(), 0, 0,
933 true);
934
935 if (workflowDefinitionLink == null) {
936 continue;
937 }
938
939 workflowDefinitionLinkLocalService.deleteWorkflowDefinitionLink(
940 workflowDefinitionLink);
941 }
942
943
944
945 if (!group.isStagingGroup() && group.isOrganization() &&
946 group.isSite()) {
947
948 group.setSite(false);
949
950 groupPersistence.update(group);
951
952
953
954 userGroupRoleLocalService.deleteUserGroupRoles(
955 group.getGroupId(), RoleConstants.TYPE_SITE);
956
957
958
959 userGroupGroupRoleLocalService.deleteUserGroupGroupRoles(
960 group.getGroupId(), RoleConstants.TYPE_SITE);
961 }
962 else {
963 groupPersistence.remove(group);
964
965
966
967 userGroupRoleLocalService.deleteUserGroupRolesByGroupId(
968 group.getGroupId());
969
970
971
972 userGroupGroupRoleLocalService.
973 deleteUserGroupGroupRolesByGroupId(group.getGroupId());
974 }
975
976
977
978 PermissionCacheUtil.clearCache();
979
980 return group;
981 }
982 finally {
983 GroupThreadLocal.setDeleteInProcess(deleteInProcess);
984 }
985 }
986
987
1001 @Override
1002 public Group deleteGroup(long groupId) throws PortalException {
1003 Group group = groupPersistence.findByPrimaryKey(groupId);
1004
1005 return deleteGroup(group);
1006 }
1007
1008 @Override
1009 public synchronized void disableStaging(long groupId)
1010 throws PortalException {
1011
1012 Group group = groupPersistence.findByPrimaryKey(groupId);
1013
1014 int stagingGroupCount = group.getRemoteStagingGroupCount();
1015
1016 if (stagingGroupCount > 0) {
1017 stagingGroupCount = stagingGroupCount - 1;
1018
1019 group.setRemoteStagingGroupCount(stagingGroupCount);
1020
1021 if (stagingGroupCount == 0) {
1022 UnicodeProperties typeSettingsProperties =
1023 group.getTypeSettingsProperties();
1024
1025 List<String> keys = new ArrayList<>();
1026
1027 for (String key : typeSettingsProperties.keySet()) {
1028 if (key.startsWith(StagingConstants.STAGED_PORTLET)) {
1029 keys.add(key);
1030 }
1031 }
1032
1033 for (String key : keys) {
1034 typeSettingsProperties.remove(key);
1035 }
1036
1037 group.setTypeSettingsProperties(typeSettingsProperties);
1038 }
1039
1040 groupPersistence.update(group);
1041 }
1042 }
1043
1044 @Override
1045 public synchronized void enableStaging(long groupId)
1046 throws PortalException {
1047
1048 Group group = groupPersistence.findByPrimaryKey(groupId);
1049
1050 int stagingGroupCount = group.getRemoteStagingGroupCount() + 1;
1051
1052 group.setRemoteStagingGroupCount(stagingGroupCount);
1053
1054 groupPersistence.update(group);
1055 }
1056
1057
1064 @Override
1065 public Group fetchCompanyGroup(long companyId) {
1066 long classNameId = classNameLocalService.getClassNameId(Company.class);
1067
1068 return groupPersistence.fetchByC_C_C(companyId, classNameId, companyId);
1069 }
1070
1071
1079 @Override
1080 public Group fetchFriendlyURLGroup(long companyId, String friendlyURL) {
1081 if (Validator.isNull(friendlyURL)) {
1082 return null;
1083 }
1084
1085 friendlyURL = getFriendlyURL(friendlyURL);
1086
1087 return groupPersistence.fetchByC_F(companyId, friendlyURL);
1088 }
1089
1090
1099 @Override
1100 @Skip
1101 public Group fetchGroup(long companyId, String groupKey) {
1102 Group group = _systemGroupsMap.get(
1103 StringUtil.toHexString(companyId).concat(groupKey));
1104
1105 if (group != null) {
1106 return group;
1107 }
1108
1109 return groupLocalService.loadFetchGroup(companyId, groupKey);
1110 }
1111
1112 @Override
1113 public Group fetchUserGroup(long companyId, long userId) {
1114 long classNameId = classNameLocalService.getClassNameId(User.class);
1115
1116 return groupPersistence.fetchByC_C_C(companyId, classNameId, userId);
1117 }
1118
1119
1127 @Override
1128 public Group fetchUserPersonalSiteGroup(long companyId)
1129 throws PortalException {
1130
1131 long classNameId = classNameLocalService.getClassNameId(
1132 UserPersonalSite.class);
1133 long defaultUserId = userLocalService.getDefaultUserId(companyId);
1134
1135 return groupPersistence.fetchByC_C_C(
1136 companyId, classNameId, defaultUserId);
1137 }
1138
1139
1147 @Override
1148 public List<Group> getActiveGroups(long companyId, boolean active) {
1149 return groupPersistence.findByC_A(companyId, active);
1150 }
1151
1152
1159 @Override
1160 public Group getCompanyGroup(long companyId) throws PortalException {
1161 long classNameId = classNameLocalService.getClassNameId(Company.class);
1162
1163 return groupPersistence.findByC_C_C(companyId, classNameId, companyId);
1164 }
1165
1166
1184 @Override
1185 public List<Group> getCompanyGroups(long companyId, int start, int end) {
1186 return groupPersistence.findByCompanyId(companyId, start, end);
1187 }
1188
1189
1195 @Override
1196 public int getCompanyGroupsCount(long companyId) {
1197 return groupPersistence.countByCompanyId(companyId);
1198 }
1199
1200
1208 @Override
1209 public Group getFriendlyURLGroup(long companyId, String friendlyURL)
1210 throws PortalException {
1211
1212 if (Validator.isNull(friendlyURL)) {
1213 StringBundler sb = new StringBundler(5);
1214
1215 sb.append("{companyId=");
1216 sb.append(companyId);
1217 sb.append(", friendlyURL=");
1218 sb.append(friendlyURL);
1219 sb.append("}");
1220
1221 throw new NoSuchGroupException(sb.toString());
1222 }
1223
1224 friendlyURL = getFriendlyURL(friendlyURL);
1225
1226 return groupPersistence.findByC_F(companyId, friendlyURL);
1227 }
1228
1229
1236 @Override
1237 @ThreadLocalCachable
1238 public Group getGroup(long groupId) throws PortalException {
1239 return groupPersistence.findByPrimaryKey(groupId);
1240 }
1241
1242
1250 @Override
1251 @Skip
1252 public Group getGroup(long companyId, String groupKey)
1253 throws PortalException {
1254
1255 Group group = _systemGroupsMap.get(
1256 StringUtil.toHexString(companyId).concat(groupKey));
1257
1258 if (group != null) {
1259 return group;
1260 }
1261
1262 return groupLocalService.loadGetGroup(companyId, groupKey);
1263 }
1264
1265
1269 @Deprecated
1270 @Override
1271 public String getGroupDescriptiveName(Group group, Locale locale)
1272 throws PortalException {
1273
1274 return group.getDescriptiveName(locale);
1275 }
1276
1277
1281 @Deprecated
1282 @Override
1283 public String getGroupDescriptiveName(long groupId, Locale locale)
1284 throws PortalException {
1285
1286 Group group = groupPersistence.findByPrimaryKey(groupId);
1287
1288 return group.getDescriptiveName(locale);
1289 }
1290
1291
1300 @Override
1301 public List<Group> getGroups(
1302 long companyId, long parentGroupId, boolean site) {
1303
1304 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
1305 return groupPersistence.findByC_S(companyId, site);
1306 }
1307
1308 return groupPersistence.findByC_P_S(companyId, parentGroupId, site);
1309 }
1310
1311 @Override
1312 public List<Group> getGroups(
1313 long companyId, long parentGroupId, boolean site,
1314 boolean inheritContent) {
1315
1316 return groupPersistence.findByC_P_S_I(
1317 companyId, parentGroupId, site, inheritContent);
1318 }
1319
1320
1330 @Override
1331 public List<Group> getGroups(
1332 long companyId, String className, long parentGroupId) {
1333
1334 long classNameId = classNameLocalService.getClassNameId(className);
1335
1336 return groupPersistence.findByC_C_P(
1337 companyId, classNameId, parentGroupId);
1338 }
1339
1340
1351 @Override
1352 public List<Group> getGroups(
1353 long companyId, String className, long parentGroupId, int start,
1354 int end) {
1355
1356 long classNameId = classNameLocalService.getClassNameId(className);
1357
1358 return groupPersistence.findByC_C_P(
1359 companyId, classNameId, parentGroupId, start, end);
1360 }
1361
1362
1369 @Override
1370 public List<Group> getGroups(long[] groupIds) throws PortalException {
1371 List<Group> groups = new ArrayList<>(groupIds.length);
1372
1373 for (long groupId : groupIds) {
1374 Group group = getGroup(groupId);
1375
1376 groups.add(group);
1377 }
1378
1379 return groups;
1380 }
1381
1382
1391 @Override
1392 public int getGroupsCount(
1393 long companyId, long parentGroupId, boolean site) {
1394
1395 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
1396 return groupPersistence.countByC_S(companyId, site);
1397 }
1398
1399 return groupPersistence.countByC_P_S(companyId, parentGroupId, site);
1400 }
1401
1402
1411 @Override
1412 public int getGroupsCount(
1413 long companyId, String className, long parentGroupId) {
1414
1415 long classNameId = classNameLocalService.getClassNameId(className);
1416
1417 return groupPersistence.countByC_C_P(
1418 companyId, classNameId, parentGroupId);
1419 }
1420
1421
1429 @Override
1430 public Group getLayoutGroup(long companyId, long plid)
1431 throws PortalException {
1432
1433 long classNameId = classNameLocalService.getClassNameId(Layout.class);
1434
1435 return groupPersistence.findByC_C_C(companyId, classNameId, plid);
1436 }
1437
1438
1446 @Override
1447 public Group getLayoutPrototypeGroup(long companyId, long layoutPrototypeId)
1448 throws PortalException {
1449
1450 long classNameId = classNameLocalService.getClassNameId(
1451 LayoutPrototype.class);
1452
1453 return groupPersistence.findByC_C_C(
1454 companyId, classNameId, layoutPrototypeId);
1455 }
1456
1457
1465 @Override
1466 public Group getLayoutSetPrototypeGroup(
1467 long companyId, long layoutSetPrototypeId)
1468 throws PortalException {
1469
1470 long classNameId = classNameLocalService.getClassNameId(
1471 LayoutSetPrototype.class);
1472
1473 return groupPersistence.findByC_C_C(
1474 companyId, classNameId, layoutSetPrototypeId);
1475 }
1476
1477
1500 @Deprecated
1501 @Override
1502 public List<Group> getLayoutsGroups(
1503 long companyId, long parentGroupId, boolean site, int start, int end) {
1504
1505 return getLayoutsGroups(
1506 companyId, parentGroupId, site, start, end, null);
1507 }
1508
1509
1533 @Override
1534 public List<Group> getLayoutsGroups(
1535 long companyId, long parentGroupId, boolean site, int start, int end,
1536 OrderByComparator<Group> obc) {
1537
1538 return groupFinder.findByLayouts(
1539 companyId, parentGroupId, site, start, end, obc);
1540 }
1541
1542
1551 @Override
1552 public int getLayoutsGroupsCount(
1553 long companyId, long parentGroupId, boolean site) {
1554
1555 return groupFinder.countByLayouts(companyId, parentGroupId, site);
1556 }
1557
1558
1563 @Override
1564 public List<Group> getLiveGroups() {
1565 return groupFinder.findByLiveGroups();
1566 }
1567
1568
1589 @Override
1590 public List<Group> getNoLayoutsGroups(
1591 String className, boolean privateLayout, int start, int end) {
1592
1593 long classNameId = classNameLocalService.getClassNameId(className);
1594
1595 return groupFinder.findByNoLayouts(
1596 classNameId, privateLayout, start, end);
1597 }
1598
1599
1606 @Override
1607 public List<Group> getNullFriendlyURLGroups() {
1608 return groupFinder.findByNullFriendlyURL();
1609 }
1610
1611
1619 @Override
1620 public Group getOrganizationGroup(long companyId, long organizationId)
1621 throws PortalException {
1622
1623 long classNameId = classNameLocalService.getClassNameId(
1624 Organization.class);
1625
1626 return groupPersistence.findByC_C_C(
1627 companyId, classNameId, organizationId);
1628 }
1629
1630
1636 @Override
1637 public List<Group> getOrganizationsGroups(
1638 List<Organization> organizations) {
1639
1640 List<Group> organizationGroups = new ArrayList<>();
1641
1642 for (int i = 0; i < organizations.size(); i++) {
1643 Organization organization = organizations.get(i);
1644
1645 Group group = organization.getGroup();
1646
1647 organizationGroups.add(group);
1648 }
1649
1650 return organizationGroups;
1651 }
1652
1653
1659 @Override
1660 public List<Group> getOrganizationsRelatedGroups(
1661 List<Organization> organizations) {
1662
1663 List<Group> organizationGroups = new ArrayList<>();
1664
1665 for (int i = 0; i < organizations.size(); i++) {
1666 Organization organization = organizations.get(i);
1667
1668 List<Group> groups = organizationPersistence.getGroups(
1669 organization.getOrganizationId());
1670
1671 organizationGroups.addAll(groups);
1672 }
1673
1674 return organizationGroups;
1675 }
1676
1677
1686 @Override
1687 public List<Group> getParentGroups(long groupId) throws PortalException {
1688 if (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
1689 return new ArrayList<>();
1690 }
1691
1692 Group group = groupPersistence.findByPrimaryKey(groupId);
1693
1694 return group.getAncestors();
1695 }
1696
1697
1704 @Override
1705 public Group getStagingGroup(long liveGroupId) throws PortalException {
1706 return groupPersistence.findByLiveGroupId(liveGroupId);
1707 }
1708
1709
1717 @Override
1718 public Group getUserGroup(long companyId, long userId)
1719 throws PortalException {
1720
1721 long classNameId = classNameLocalService.getClassNameId(User.class);
1722
1723 return groupPersistence.findByC_C_C(companyId, classNameId, userId);
1724 }
1725
1726
1735 @Override
1736 public Group getUserGroupGroup(long companyId, long userGroupId)
1737 throws PortalException {
1738
1739 long classNameId = classNameLocalService.getClassNameId(
1740 UserGroup.class);
1741
1742 return groupPersistence.findByC_C_C(
1743 companyId, classNameId, userGroupId);
1744 }
1745
1746
1757 @Override
1758 public List<Group> getUserGroups(long userId, boolean inherit)
1759 throws PortalException {
1760
1761 return getUserGroups(
1762 userId, inherit, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1763 }
1764
1765
1790 @Override
1791 public List<Group> getUserGroups(
1792 long userId, boolean inherit, int start, int end)
1793 throws PortalException {
1794
1795 if (inherit) {
1796 User user = userPersistence.findByPrimaryKey(userId);
1797
1798 LinkedHashMap<String, Object> groupParams = new LinkedHashMap<>();
1799
1800 groupParams.put("usersGroups", Long.valueOf(userId));
1801
1802 return search(
1803 user.getCompanyId(), null, null, groupParams, start, end);
1804 }
1805 else {
1806 return userPersistence.getGroups(userId, start, end);
1807 }
1808 }
1809
1810
1817 @Override
1818 public List<Group> getUserGroupsGroups(List<UserGroup> userGroups)
1819 throws PortalException {
1820
1821 List<Group> userGroupGroups = new ArrayList<>();
1822
1823 for (int i = 0; i < userGroups.size(); i++) {
1824 UserGroup userGroup = userGroups.get(i);
1825
1826 Group group = userGroup.getGroup();
1827
1828 userGroupGroups.add(group);
1829 }
1830
1831 return userGroupGroups;
1832 }
1833
1834
1840 @Override
1841 public List<Group> getUserGroupsRelatedGroups(List<UserGroup> userGroups) {
1842 List<Group> userGroupGroups = new ArrayList<>();
1843
1844 for (int i = 0; i < userGroups.size(); i++) {
1845 UserGroup userGroup = userGroups.get(i);
1846
1847 List<Group> groups = userGroupPersistence.getGroups(
1848 userGroup.getUserGroupId());
1849
1850 userGroupGroups.addAll(groups);
1851 }
1852
1853 return userGroupGroups;
1854 }
1855
1856
1879 @Override
1880 public List<Group> getUserOrganizationsGroups(
1881 long userId, int start, int end)
1882 throws PortalException {
1883
1884 List<Group> userOrgsGroups = new ArrayList<>();
1885
1886 List<Organization> userOrgs =
1887 organizationLocalService.getUserOrganizations(userId, start, end);
1888
1889 for (Organization organization : userOrgs) {
1890 userOrgsGroups.add(0, organization.getGroup());
1891
1892 if (!PropsValues.ORGANIZATIONS_MEMBERSHIP_STRICT) {
1893 for (Organization ancestorOrganization :
1894 organization.getAncestors()) {
1895
1896 userOrgsGroups.add(0, ancestorOrganization.getGroup());
1897 }
1898 }
1899 }
1900
1901 return ListUtil.unique(userOrgsGroups);
1902 }
1903
1904
1911 @Override
1912 public Group getUserPersonalSiteGroup(long companyId)
1913 throws PortalException {
1914
1915 long classNameId = classNameLocalService.getClassNameId(
1916 UserPersonalSite.class);
1917 long defaultUserId = userLocalService.getDefaultUserId(companyId);
1918
1919 return groupPersistence.findByC_C_C(
1920 companyId, classNameId, defaultUserId);
1921 }
1922
1923 @Override
1924 public List<Group> getUserSitesGroups(long userId) throws PortalException {
1925 User user = userPersistence.findByPrimaryKey(userId);
1926
1927 LinkedHashMap<String, Object> groupParams = new LinkedHashMap<>();
1928
1929 groupParams.put("inherit", Boolean.TRUE);
1930 groupParams.put("site", Boolean.TRUE);
1931 groupParams.put("usersGroups", userId);
1932
1933 return groupFinder.findByCompanyId(
1934 user.getCompanyId(), groupParams, QueryUtil.ALL_POS,
1935 QueryUtil.ALL_POS, new GroupNameComparator(true));
1936 }
1937
1938 @Override
1939 public List<Group> getUserSitesGroups(
1940 long userId, boolean includeAdministrative)
1941 throws PortalException {
1942
1943 if (!includeAdministrative) {
1944 return getUserSitesGroups(userId);
1945 }
1946
1947 Set<Group> sites = new HashSet<>();
1948
1949 List<UserGroupRole> userGroupRoles =
1950 userGroupRoleLocalService.getUserGroupRoles(userId);
1951
1952 for (UserGroupRole userGroupRole : userGroupRoles) {
1953 Role role = userGroupRole.getRole();
1954
1955 String roleName = role.getName();
1956
1957 if (roleName.equals(RoleConstants.SITE_ADMINISTRATOR) ||
1958 roleName.equals(RoleConstants.SITE_OWNER)) {
1959
1960 Group group = userGroupRole.getGroup();
1961
1962 sites.add(group);
1963 }
1964 }
1965
1966 sites.addAll(getUserSitesGroups(userId));
1967
1968 return new ArrayList<>(sites);
1969 }
1970
1971
1978 @Override
1979 public boolean hasStagingGroup(long liveGroupId) {
1980 if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
1981 return true;
1982 }
1983 else {
1984 return false;
1985 }
1986 }
1987
1988
1998 @Override
1999 public boolean hasUserGroup(long userId, long groupId) {
2000 return hasUserGroup(userId, groupId, true);
2001 }
2002
2003
2015 @Override
2016 public boolean hasUserGroup(long userId, long groupId, boolean inherit) {
2017 if (groupFinder.countByG_U(groupId, userId, inherit) > 0) {
2018 return true;
2019 }
2020 else {
2021 return false;
2022 }
2023 }
2024
2025
2034 @Override
2035 public Group loadFetchGroup(long companyId, String groupKey) {
2036 return groupPersistence.fetchByC_GK(companyId, groupKey);
2037 }
2038
2039
2047 @Override
2048 public Group loadGetGroup(long companyId, String groupKey)
2049 throws PortalException {
2050
2051 return groupPersistence.findByC_GK(companyId, groupKey);
2052 }
2053
2054
2066 @Override
2067 public void rebuildTree(long companyId) throws PortalException {
2068 TreePathUtil.rebuildTree(
2069 companyId, GroupConstants.DEFAULT_PARENT_GROUP_ID, StringPool.SLASH,
2070 new TreeModelTasksAdapter<Group>() {
2071
2072 @Override
2073 public List<Group> findTreeModels(
2074 long previousId, long companyId, long parentPrimaryKey,
2075 int size) {
2076
2077 return groupPersistence.findByG_C_P(
2078 previousId, companyId, parentPrimaryKey,
2079 QueryUtil.ALL_POS, size, new GroupIdComparator(true));
2080 }
2081
2082 }
2083 );
2084 }
2085
2086
2113 @Override
2114 public List<Group> search(
2115 long companyId, LinkedHashMap<String, Object> params, int start,
2116 int end) {
2117
2118 return groupFinder.findByCompanyId(
2119 companyId, params, start, end, new GroupNameComparator(true));
2120 }
2121
2122
2152 @Override
2153 public List<Group> search(
2154 long companyId, long parentGroupId, String keywords,
2155 LinkedHashMap<String, Object> params, int start, int end) {
2156
2157 return search(
2158 companyId, getClassNameIds(), parentGroupId, keywords, params,
2159 start, end, null);
2160 }
2161
2162
2194 @Override
2195 public List<Group> search(
2196 long companyId, long parentGroupId, String keywords,
2197 LinkedHashMap<String, Object> params, int start, int end,
2198 OrderByComparator<Group> obc) {
2199
2200 return search(
2201 companyId, getClassNameIds(), parentGroupId, keywords, params,
2202 start, end, obc);
2203 }
2204
2205
2238 @Override
2239 public List<Group> search(
2240 long companyId, long parentGroupId, String name, String description,
2241 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2242 int end) {
2243
2244 return search(
2245 companyId, getClassNameIds(), parentGroupId, name, description,
2246 params, andOperator, start, end, null);
2247 }
2248
2249
2284 @Override
2285 public List<Group> search(
2286 long companyId, long parentGroupId, String name, String description,
2287 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2288 int end, OrderByComparator<Group> obc) {
2289
2290 return search(
2291 companyId, getClassNameIds(), parentGroupId, name, description,
2292 params, andOperator, start, end, obc);
2293 }
2294
2295
2328 @Override
2329 public List<Group> search(
2330 long companyId, long[] classNameIds, long parentGroupId,
2331 String keywords, LinkedHashMap<String, Object> params, int start,
2332 int end) {
2333
2334 return search(
2335 companyId, classNameIds, parentGroupId, keywords, params, start,
2336 end, null);
2337 }
2338
2339
2374 @Override
2375 public List<Group> search(
2376 long companyId, long[] classNameIds, long parentGroupId,
2377 String keywords, LinkedHashMap<String, Object> params, int start,
2378 int end, OrderByComparator<Group> obc) {
2379
2380 String[] keywordsArray = getSearchNames(companyId, keywords);
2381
2382 boolean andOperator = false;
2383
2384 if (Validator.isNull(keywords)) {
2385 andOperator = true;
2386 }
2387
2388 if (isUseComplexSQL(classNameIds)) {
2389 return groupFinder.findByC_C_PG_N_D(
2390 companyId, classNameIds, parentGroupId, keywordsArray,
2391 keywordsArray, params, andOperator, start, end, obc);
2392 }
2393
2394 Collection<Group> groups = doSearch(
2395 companyId, classNameIds, parentGroupId, keywordsArray,
2396 keywordsArray, params, andOperator);
2397
2398 return sort(groups, start, end, obc);
2399 }
2400
2401
2437 @Override
2438 public List<Group> search(
2439 long companyId, long[] classNameIds, long parentGroupId, String name,
2440 String description, LinkedHashMap<String, Object> params,
2441 boolean andOperator, int start, int end) {
2442
2443 return search(
2444 companyId, classNameIds, parentGroupId, name, description, params,
2445 andOperator, start, end, null);
2446 }
2447
2448
2486 @Override
2487 public List<Group> search(
2488 long companyId, long[] classNameIds, long parentGroupId, String name,
2489 String description, LinkedHashMap<String, Object> params,
2490 boolean andOperator, int start, int end, OrderByComparator<Group> obc) {
2491
2492 String[] names = getSearchNames(companyId, name);
2493 String[] descriptions = CustomSQLUtil.keywords(description);
2494
2495 if (isUseComplexSQL(classNameIds)) {
2496 return groupFinder.findByC_C_PG_N_D(
2497 companyId, classNameIds, parentGroupId, names, descriptions,
2498 params, andOperator, start, end, obc);
2499 }
2500
2501 Collection<Group> groups = doSearch(
2502 companyId, classNameIds, parentGroupId, names, descriptions, params,
2503 andOperator);
2504
2505 return sort(groups, start, end, obc);
2506 }
2507
2508
2539 @Override
2540 public List<Group> search(
2541 long companyId, long[] classNameIds, String keywords,
2542 LinkedHashMap<String, Object> params, int start, int end) {
2543
2544 return search(
2545 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
2546 keywords, params, start, end, null);
2547 }
2548
2549
2582 @Override
2583 public List<Group> search(
2584 long companyId, long[] classNameIds, String keywords,
2585 LinkedHashMap<String, Object> params, int start, int end,
2586 OrderByComparator<Group> obc) {
2587
2588 return search(
2589 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
2590 keywords, params, start, end, obc);
2591 }
2592
2593
2628 @Override
2629 public List<Group> search(
2630 long companyId, long[] classNameIds, String name, String description,
2631 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2632 int end) {
2633
2634 return search(
2635 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
2636 description, params, andOperator, start, end, null);
2637 }
2638
2639
2676 @Override
2677 public List<Group> search(
2678 long companyId, long[] classNameIds, String name, String description,
2679 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2680 int end, OrderByComparator<Group> obc) {
2681
2682 return search(
2683 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
2684 description, params, andOperator, start, end, obc);
2685 }
2686
2687
2715 @Override
2716 @ThreadLocalCachable
2717 public List<Group> search(
2718 long companyId, String keywords, LinkedHashMap<String, Object> params,
2719 int start, int end) {
2720
2721 return search(
2722 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2723 keywords, params, start, end, null);
2724 }
2725
2726
2756 @Override
2757 public List<Group> search(
2758 long companyId, String keywords, LinkedHashMap<String, Object> params,
2759 int start, int end, OrderByComparator<Group> obc) {
2760
2761 return search(
2762 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2763 keywords, params, start, end, obc);
2764 }
2765
2766
2798 @Override
2799 public List<Group> search(
2800 long companyId, String name, String description,
2801 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2802 int end) {
2803
2804 return search(
2805 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2806 name, description, params, andOperator, start, end, null);
2807 }
2808
2809
2843 @Override
2844 public List<Group> search(
2845 long companyId, String name, String description,
2846 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2847 int end, OrderByComparator<Group> obc) {
2848
2849 return search(
2850 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2851 name, description, params, andOperator, start, end, obc);
2852 }
2853
2854
2871 @Override
2872 @ThreadLocalCachable
2873 public int searchCount(
2874 long companyId, long parentGroupId, String keywords,
2875 LinkedHashMap<String, Object> params) {
2876
2877 return searchCount(
2878 companyId, getClassNameIds(), parentGroupId, keywords, params);
2879 }
2880
2881
2902 @Override
2903 @ThreadLocalCachable
2904 public int searchCount(
2905 long companyId, long parentGroupId, String name, String description,
2906 LinkedHashMap<String, Object> params, boolean andOperator) {
2907
2908 return searchCount(
2909 companyId, getClassNameIds(), parentGroupId, name, description,
2910 params, andOperator);
2911 }
2912
2913
2933 @Override
2934 @ThreadLocalCachable
2935 public int searchCount(
2936 long companyId, long[] classNameIds, long parentGroupId,
2937 String keywords, LinkedHashMap<String, Object> params) {
2938
2939 String[] keywordsArray = getSearchNames(companyId, keywords);
2940
2941 boolean andOperator = false;
2942
2943 if (Validator.isNull(keywords)) {
2944 andOperator = true;
2945 }
2946
2947 if (isUseComplexSQL(classNameIds)) {
2948 return groupFinder.countByC_C_PG_N_D(
2949 companyId, classNameIds, parentGroupId, keywordsArray,
2950 keywordsArray, params, andOperator);
2951 }
2952
2953 Collection<Group> groups = doSearch(
2954 companyId, classNameIds, parentGroupId, keywordsArray,
2955 keywordsArray, params, andOperator);
2956
2957 return groups.size();
2958 }
2959
2960
2983 @Override
2984 @ThreadLocalCachable
2985 public int searchCount(
2986 long companyId, long[] classNameIds, long parentGroupId, String name,
2987 String description, LinkedHashMap<String, Object> params,
2988 boolean andOperator) {
2989
2990 String[] names = getSearchNames(companyId, name);
2991 String[] descriptions = CustomSQLUtil.keywords(description);
2992
2993 if (isUseComplexSQL(classNameIds)) {
2994 return groupFinder.countByC_C_PG_N_D(
2995 companyId, classNameIds, parentGroupId, names, descriptions,
2996 params, andOperator);
2997 }
2998
2999 Collection<Group> groups = doSearch(
3000 companyId, classNameIds, parentGroupId, names, descriptions, params,
3001 andOperator);
3002
3003 return groups.size();
3004 }
3005
3006
3024 @Override
3025 @ThreadLocalCachable
3026 public int searchCount(
3027 long companyId, long[] classNameIds, String keywords,
3028 LinkedHashMap<String, Object> params) {
3029
3030 return searchCount(
3031 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
3032 keywords, params);
3033 }
3034
3035
3056 @Override
3057 @ThreadLocalCachable
3058 public int searchCount(
3059 long companyId, long[] classNameIds, String name, String description,
3060 LinkedHashMap<String, Object> params, boolean andOperator) {
3061
3062 return searchCount(
3063 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
3064 description, params, andOperator);
3065 }
3066
3067
3083 @Override
3084 @ThreadLocalCachable
3085 public int searchCount(
3086 long companyId, String keywords, LinkedHashMap<String, Object> params) {
3087
3088 return searchCount(
3089 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
3090 keywords, params);
3091 }
3092
3093
3113 @Override
3114 @ThreadLocalCachable
3115 public int searchCount(
3116 long companyId, String name, String description,
3117 LinkedHashMap<String, Object> params, boolean andOperator) {
3118
3119 return searchCount(
3120 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
3121 name, description, params, andOperator);
3122 }
3123
3124
3131 @Override
3132 public void setRoleGroups(long roleId, long[] groupIds) {
3133 rolePersistence.setGroups(roleId, groupIds);
3134
3135 PermissionCacheUtil.clearCache();
3136 }
3137
3138
3144 @Override
3145 public void unsetRoleGroups(long roleId, long[] groupIds) {
3146 rolePersistence.removeGroups(roleId, groupIds);
3147
3148 PermissionCacheUtil.clearCache();
3149 }
3150
3151
3157 @Override
3158 public void unsetUserGroups(long userId, long[] groupIds) {
3159 userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
3160
3161 userPersistence.removeGroups(userId, groupIds);
3162
3163 PermissionCacheUtil.clearCache(userId);
3164 }
3165
3166
3176 @Override
3177 public void updateAsset(
3178 long userId, Group group, long[] assetCategoryIds,
3179 String[] assetTagNames)
3180 throws PortalException {
3181
3182 User user = userPersistence.findByPrimaryKey(userId);
3183
3184 Company company = companyPersistence.findByPrimaryKey(
3185 user.getCompanyId());
3186
3187 Group companyGroup = company.getGroup();
3188
3189 assetEntryLocalService.updateEntry(
3190 userId, companyGroup.getGroupId(), null, null,
3191 Group.class.getName(), group.getGroupId(), null, 0,
3192 assetCategoryIds, assetTagNames, false, null, null, null, null,
3193 group.getDescriptiveName(), group.getDescription(), null, null,
3194 null, 0, 0, null);
3195 }
3196
3197
3206 @Override
3207 public Group updateFriendlyURL(long groupId, String friendlyURL)
3208 throws PortalException {
3209
3210 Group group = groupPersistence.findByPrimaryKey(groupId);
3211
3212 if (group.isUser()) {
3213 User user = userPersistence.findByPrimaryKey(group.getClassPK());
3214
3215 friendlyURL = StringPool.SLASH + user.getScreenName();
3216
3217 if (group.getFriendlyURL().equals(friendlyURL)) {
3218 return group;
3219 }
3220 }
3221
3222 friendlyURL = getFriendlyURL(
3223 group.getCompanyId(), groupId, group.getClassNameId(),
3224 group.getClassPK(), StringPool.BLANK, friendlyURL);
3225
3226 validateFriendlyURL(
3227 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
3228 group.getClassPK(), friendlyURL);
3229
3230 group.setFriendlyURL(friendlyURL);
3231
3232 groupPersistence.update(group);
3233
3234 return group;
3235 }
3236
3237 @Override
3238 public Group updateGroup(
3239 long groupId, long parentGroupId, Map<Locale, String> nameMap,
3240 Map<Locale, String> descriptionMap, int type,
3241 boolean manualMembership, int membershipRestriction,
3242 String friendlyURL, boolean inheritContent, boolean active,
3243 ServiceContext serviceContext)
3244 throws PortalException {
3245
3246 Group group = groupPersistence.findByPrimaryKey(groupId);
3247
3248 String className = group.getClassName();
3249 long classNameId = group.getClassNameId();
3250 long classPK = group.getClassPK();
3251
3252 String groupKey = group.getGroupKey();
3253
3254 if ((nameMap != null) &&
3255 Validator.isNotNull(nameMap.get(LocaleUtil.getDefault()))) {
3256
3257 groupKey = nameMap.get(LocaleUtil.getDefault());
3258 }
3259
3260 friendlyURL = getFriendlyURL(
3261 group.getCompanyId(), groupId, classNameId, classPK,
3262 StringPool.BLANK, friendlyURL);
3263
3264 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
3265 validateGroupKey(
3266 group.getGroupId(), group.getCompanyId(), groupKey,
3267 group.isSite());
3268 }
3269 else if (className.equals(Organization.class.getName())) {
3270 Organization organization =
3271 organizationPersistence.findByPrimaryKey(classPK);
3272
3273 groupKey = getOrgGroupName(organization.getName());
3274 }
3275 else if (!GroupConstants.USER_PERSONAL_SITE.equals(
3276 group.getGroupKey())) {
3277
3278 groupKey = String.valueOf(classPK);
3279 }
3280
3281 if (PortalUtil.isSystemGroup(group.getGroupKey()) &&
3282 !groupKey.equals(group.getGroupKey())) {
3283
3284 throw new RequiredGroupException.MustNotDeleteSystemGroup(
3285 group.getGroupId());
3286 }
3287
3288 validateFriendlyURL(
3289 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
3290 group.getClassPK(), friendlyURL);
3291
3292 validateParentGroup(group.getGroupId(), parentGroupId);
3293
3294 group.setParentGroupId(parentGroupId);
3295 group.setTreePath(group.buildTreePath());
3296 group.setGroupKey(groupKey);
3297 group.setNameMap(nameMap);
3298 group.setDescriptionMap(descriptionMap);
3299 group.setType(type);
3300 group.setManualMembership(manualMembership);
3301 group.setMembershipRestriction(membershipRestriction);
3302 group.setFriendlyURL(friendlyURL);
3303 group.setInheritContent(inheritContent);
3304 group.setActive(active);
3305
3306 if ((serviceContext != null) && group.isSite()) {
3307 group.setExpandoBridgeAttributes(serviceContext);
3308 }
3309
3310 groupPersistence.update(group);
3311
3312
3313
3314 if ((serviceContext == null) || !group.isSite()) {
3315 return group;
3316 }
3317
3318 User user = null;
3319
3320 user = userPersistence.fetchByPrimaryKey(group.getCreatorUserId());
3321
3322 if (user == null) {
3323 user = userPersistence.fetchByPrimaryKey(
3324 serviceContext.getUserId());
3325 }
3326
3327 if (user == null) {
3328 user = userLocalService.getDefaultUser(group.getCompanyId());
3329 }
3330
3331 updateAsset(
3332 user.getUserId(), group, serviceContext.getAssetCategoryIds(),
3333 serviceContext.getAssetTagNames());
3334
3335 return group;
3336 }
3337
3338
3366 @Deprecated
3367 @Override
3368 public Group updateGroup(
3369 long groupId, long parentGroupId, String name, String description,
3370 int type, boolean manualMembership, int membershipRestriction,
3371 String friendlyURL, boolean inheritContent, boolean active,
3372 ServiceContext serviceContext)
3373 throws PortalException {
3374
3375 return updateGroup(
3376 groupId, parentGroupId, getLocalizationMap(name),
3377 getLocalizationMap(description), type, manualMembership,
3378 membershipRestriction, friendlyURL, inheritContent, active,
3379 serviceContext);
3380 }
3381
3382
3391 @Override
3392 public Group updateGroup(long groupId, String typeSettings)
3393 throws PortalException {
3394
3395 Group group = groupPersistence.findByPrimaryKey(groupId);
3396
3397 UnicodeProperties oldTypeSettingsProperties =
3398 group.getTypeSettingsProperties();
3399
3400 UnicodeProperties typeSettingsProperties = new UnicodeProperties(true);
3401
3402 typeSettingsProperties.fastLoad(typeSettings);
3403
3404 String newLanguageIds = typeSettingsProperties.getProperty(
3405 PropsKeys.LOCALES);
3406
3407 if (Validator.isNotNull(newLanguageIds)) {
3408 String oldLanguageIds = oldTypeSettingsProperties.getProperty(
3409 PropsKeys.LOCALES, StringPool.BLANK);
3410
3411 String defaultLanguageId = typeSettingsProperties.getProperty(
3412 "languageId", LocaleUtil.toLanguageId(LocaleUtil.getDefault()));
3413
3414 validateLanguageIds(defaultLanguageId, newLanguageIds);
3415
3416 if (!Validator.equals(oldLanguageIds, newLanguageIds)) {
3417 LanguageUtil.resetAvailableGroupLocales(groupId);
3418 }
3419 }
3420
3421 group.setTypeSettings(typeSettings);
3422
3423 groupPersistence.update(group);
3424
3425 return group;
3426 }
3427
3428
3436 @Override
3437 public Group updateSite(long groupId, boolean site) throws PortalException {
3438 Group group = groupPersistence.findByPrimaryKey(groupId);
3439
3440 if (!group.isOrganization()) {
3441 return group;
3442 }
3443
3444 group.setSite(site);
3445
3446 groupPersistence.update(group);
3447
3448 return group;
3449 }
3450
3451 protected void addControlPanelLayouts(Group group) throws PortalException {
3452 long defaultUserId = userLocalService.getDefaultUserId(
3453 group.getCompanyId());
3454
3455 String friendlyURL = getFriendlyURL(
3456 PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
3457
3458 ServiceContext serviceContext = new ServiceContext();
3459
3460 serviceContext.setAttribute(
3461 "layout.instanceable.allowed", Boolean.TRUE);
3462
3463 layoutLocalService.addLayout(
3464 defaultUserId, group.getGroupId(), true,
3465 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
3466 PropsValues.CONTROL_PANEL_LAYOUT_NAME, StringPool.BLANK,
3467 StringPool.BLANK, LayoutConstants.TYPE_CONTROL_PANEL, false,
3468 friendlyURL, serviceContext);
3469 }
3470
3471 protected void addDefaultGuestPublicLayoutByProperties(Group group)
3472 throws PortalException {
3473
3474 List<Portlet> portlets = portletLocalService.getPortlets(
3475 group.getCompanyId());
3476
3477 if (portlets.isEmpty()) {
3478
3479
3480
3481 return;
3482 }
3483
3484 long defaultUserId = userLocalService.getDefaultUserId(
3485 group.getCompanyId());
3486 String friendlyURL = getFriendlyURL(
3487 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
3488
3489 ServiceContext serviceContext = new ServiceContext();
3490
3491 Layout layout = layoutLocalService.addLayout(
3492 defaultUserId, group.getGroupId(), false,
3493 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
3494 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
3495 StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL,
3496 serviceContext);
3497
3498 LayoutTypePortlet layoutTypePortlet =
3499 (LayoutTypePortlet)layout.getLayoutType();
3500
3501 layoutTypePortlet.setLayoutTemplateId(
3502 0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
3503
3504 LayoutTemplate layoutTemplate = layoutTypePortlet.getLayoutTemplate();
3505
3506 for (String columnId : layoutTemplate.getColumns()) {
3507 String keyPrefix = PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_PREFIX;
3508
3509 String portletIds = PropsUtil.get(keyPrefix.concat(columnId));
3510
3511 layoutTypePortlet.addPortletIds(
3512 0, StringUtil.split(portletIds), columnId, false);
3513 }
3514
3515 layoutLocalService.updateLayout(
3516 layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
3517 layout.getTypeSettings());
3518
3519 boolean updateLayoutSet = false;
3520
3521 LayoutSet layoutSet = layout.getLayoutSet();
3522
3523 if (Validator.isNotNull(
3524 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
3525
3526 layoutSet.setThemeId(
3527 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
3528
3529 updateLayoutSet = true;
3530 }
3531
3532 if (Validator.isNotNull(
3533 PropsValues.
3534 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
3535
3536 layoutSet.setColorSchemeId(
3537 PropsValues.
3538 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
3539
3540 updateLayoutSet = true;
3541 }
3542
3543 if (Validator.isNotNull(
3544 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
3545
3546 layoutSet.setWapThemeId(
3547 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
3548
3549 updateLayoutSet = true;
3550 }
3551
3552 if (Validator.isNotNull(
3553 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
3554
3555 layoutSet.setWapColorSchemeId(
3556 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
3557
3558 updateLayoutSet = true;
3559 }
3560
3561 if (updateLayoutSet) {
3562 layoutSetLocalService.updateLayoutSet(layoutSet);
3563 }
3564 }
3565
3566 protected void addDefaultGuestPublicLayouts(Group group)
3567 throws PortalException {
3568
3569 if (publicLARFile != null) {
3570 addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
3571 }
3572 else {
3573 addDefaultGuestPublicLayoutByProperties(group);
3574 }
3575 }
3576
3577 protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
3578 throws PortalException {
3579
3580 User defaultUser = userLocalService.getDefaultUser(
3581 group.getCompanyId());
3582
3583 Map<String, String[]> parameterMap = new HashMap<>();
3584
3585 parameterMap.put(
3586 PortletDataHandlerKeys.PERMISSIONS,
3587 new String[] {Boolean.TRUE.toString()});
3588 parameterMap.put(
3589 PortletDataHandlerKeys.PORTLET_CONFIGURATION,
3590 new String[] {Boolean.TRUE.toString()});
3591 parameterMap.put(
3592 PortletDataHandlerKeys.PORTLET_DATA,
3593 new String[] {Boolean.TRUE.toString()});
3594 parameterMap.put(
3595 PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
3596 new String[] {Boolean.TRUE.toString()});
3597
3598 Map<String, Serializable> importLayoutSettingsMap =
3599 ExportImportConfigurationSettingsMapFactory.
3600 buildImportLayoutSettingsMap(
3601 defaultUser, group.getGroupId(), false, null, parameterMap);
3602
3603 ExportImportConfiguration exportImportConfiguration =
3604 exportImportConfigurationLocalService.
3605 addDraftExportImportConfiguration(
3606 defaultUser.getUserId(),
3607 ExportImportConfigurationConstants.TYPE_IMPORT_LAYOUT,
3608 importLayoutSettingsMap);
3609
3610 exportImportLocalService.importLayouts(
3611 exportImportConfiguration, larFile);
3612 }
3613
3614 protected void addPortletDefaultData(Group group) throws PortalException {
3615 PortletDataContext portletDataContext =
3616 PortletDataContextFactoryUtil.createPreparePortletDataContext(
3617 group.getCompanyId(), group.getGroupId(), null, null);
3618
3619 List<PortletDataHandler> portletDataHandlers = getPortletDataHandlers(
3620 group);
3621
3622 for (PortletDataHandler portletDataHandler : portletDataHandlers) {
3623 try {
3624 portletDataHandler.addDefaultData(
3625 portletDataContext, portletDataHandler.getPortletId(),
3626 null);
3627 }
3628 catch (Exception e) {
3629 _log.error(
3630 "Unable to add default data for portlet " +
3631 portletDataHandler.getPortletId() + " in group " +
3632 group.getGroupId());
3633
3634 if (portletDataHandler.isRollbackOnException()) {
3635 throw new SystemException(e);
3636 }
3637 }
3638 }
3639 }
3640
3641 protected void deletePortletData(Group group) throws PortalException {
3642 PortletDataContext portletDataContext =
3643 PortletDataContextFactoryUtil.createPreparePortletDataContext(
3644 group.getCompanyId(), group.getGroupId(), null, null);
3645
3646 List<PortletDataHandler> portletDataHandlers = getPortletDataHandlers(
3647 group);
3648
3649 for (PortletDataHandler portletDataHandler : portletDataHandlers) {
3650 try {
3651 portletDataHandler.deleteData(
3652 portletDataContext, portletDataHandler.getPortletId(),
3653 null);
3654 }
3655 catch (Exception e) {
3656 _log.error(
3657 "Unable to delete data for portlet " +
3658 portletDataHandler.getPortletId() + " in group " +
3659 group.getGroupId());
3660
3661 if (portletDataHandler.isRollbackOnException()) {
3662 throw new SystemException(e);
3663 }
3664 }
3665 }
3666 }
3667
3668 protected Collection<Group> doSearch(
3669 long companyId, long[] classNameIds, long parentGroupId, String[] names,
3670 String[] descriptions, LinkedHashMap<String, Object> params,
3671 boolean andOperator) {
3672
3673 boolean parentGroupIdEquals = true;
3674
3675 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
3676 parentGroupIdEquals = false;
3677 }
3678
3679 params = new LinkedHashMap<>(params);
3680
3681 Boolean active = (Boolean)params.remove("active");
3682 List<Long> excludedGroupIds = (List<Long>)params.remove(
3683 "excludedGroupIds");
3684 List<Group> groupsTree = (List<Group>)params.remove("groupsTree");
3685 Boolean manualMembership = (Boolean)params.remove("manualMembership");
3686 Integer membershipRestriction = (Integer)params.remove(
3687 "membershipRestriction");
3688 Boolean site = (Boolean)params.remove("site");
3689 List<Integer> types = (List<Integer>)params.remove("types");
3690
3691 Collection<Group> groups = new HashSet<>();
3692
3693 Long userId = (Long)params.remove("usersGroups");
3694
3695 for (long classNameId : classNameIds) {
3696 groups.addAll(groupPersistence.findByC_C(companyId, classNameId));
3697 }
3698
3699 Iterator<Group> iterator = groups.iterator();
3700
3701 while (iterator.hasNext()) {
3702 Group group = iterator.next();
3703
3704
3705
3706 long liveGroupId = group.getLiveGroupId();
3707
3708 if (liveGroupId != 0) {
3709 iterator.remove();
3710
3711 continue;
3712 }
3713
3714
3715
3716 long groupParentGroupId = group.getParentGroupId();
3717
3718 if ((parentGroupIdEquals &&
3719 (groupParentGroupId != parentGroupId)) ||
3720 (!parentGroupIdEquals &&
3721 (groupParentGroupId == parentGroupId))) {
3722
3723 iterator.remove();
3724
3725 continue;
3726 }
3727
3728
3729
3730 String groupKey = group.getGroupKey();
3731
3732 if (groupKey.equals(GroupConstants.CONTROL_PANEL)) {
3733 iterator.remove();
3734
3735 continue;
3736 }
3737
3738 boolean containsName = matches(group.getNameCurrentValue(), names);
3739 boolean containsDescription = matches(
3740 group.getDescriptionCurrentValue(), descriptions);
3741
3742 if ((andOperator && (!containsName || !containsDescription)) ||
3743 (!andOperator && !containsName && !containsDescription)) {
3744
3745 iterator.remove();
3746
3747 continue;
3748 }
3749
3750
3751
3752 if (active != null) {
3753 if (active != group.isActive()) {
3754 iterator.remove();
3755
3756 continue;
3757 }
3758 }
3759
3760
3761
3762 if ((excludedGroupIds != null) &&
3763 excludedGroupIds.contains(group.getGroupId())) {
3764
3765 iterator.remove();
3766
3767 continue;
3768 }
3769
3770
3771
3772 if (groupsTree != null) {
3773 String treePath = group.getTreePath();
3774
3775 boolean matched = false;
3776
3777 for (Group groupTree : groupsTree) {
3778 String groupTreePath = StringUtil.quote(
3779 String.valueOf(groupTree.getGroupId()),
3780 StringPool.SLASH);
3781
3782 if (treePath.contains(groupTreePath)) {
3783 matched = true;
3784
3785 break;
3786 }
3787 }
3788
3789 if (!matched) {
3790 iterator.remove();
3791
3792 continue;
3793 }
3794 }
3795
3796
3797
3798 if ((manualMembership != null) &&
3799 (manualMembership != group.isManualMembership())) {
3800
3801 iterator.remove();
3802
3803 continue;
3804 }
3805
3806
3807
3808 if ((membershipRestriction != null) &&
3809 (membershipRestriction != group.getMembershipRestriction())) {
3810
3811 iterator.remove();
3812
3813 continue;
3814 }
3815
3816
3817
3818 if (site != null) {
3819 if (site != group.isSite()) {
3820 iterator.remove();
3821
3822 continue;
3823 }
3824 }
3825
3826
3827
3828 int type = group.getType();
3829
3830 if (type == 4) {
3831 iterator.remove();
3832
3833 continue;
3834 }
3835
3836 if ((types != null) && !types.contains(type)) {
3837 iterator.remove();
3838
3839 continue;
3840 }
3841 }
3842
3843
3844
3845 RolePermissions rolePermissions = (RolePermissions)params.remove(
3846 "rolePermissions");
3847
3848 if (rolePermissions != null) {
3849 ResourceAction resourceAction =
3850 resourceActionLocalService.fetchResourceAction(
3851 rolePermissions.getName(), rolePermissions.getActionId());
3852
3853 if (resourceAction != null) {
3854 Set<Group> rolePermissionsGroups = new HashSet<>();
3855
3856 if (resourceBlockLocalService.isSupported(
3857 rolePermissions.getName())) {
3858
3859 List<ResourceTypePermission> resourceTypePermissions =
3860 resourceTypePermissionPersistence.findByRoleId(
3861 rolePermissions.getRoleId());
3862
3863 for (ResourceTypePermission resourceTypePermission :
3864 resourceTypePermissions) {
3865
3866 if ((resourceTypePermission.getCompanyId() ==
3867 companyId) &&
3868 Validator.equals(
3869 rolePermissions.getName(),
3870 resourceTypePermission.getName()) &&
3871 resourceTypePermission.hasAction(resourceAction)) {
3872
3873 Group group = groupPersistence.fetchByPrimaryKey(
3874 resourceTypePermission.getGroupId());
3875
3876 if (group != null) {
3877 rolePermissionsGroups.add(group);
3878 }
3879 }
3880 }
3881 }
3882 else {
3883 List<ResourcePermission> resourcePermissions =
3884 resourcePermissionPersistence.findByC_N_S(
3885 companyId, rolePermissions.getName(),
3886 rolePermissions.getScope());
3887
3888 for (ResourcePermission resourcePermission :
3889 resourcePermissions) {
3890
3891 if ((resourcePermission.getRoleId() ==
3892 rolePermissions.getRoleId()) &&
3893 resourcePermission.hasAction(
3894 resourceAction)) {
3895
3896 Group group = groupPersistence.fetchByPrimaryKey(
3897 GetterUtil.getLong(
3898 resourcePermission.getPrimKey()));
3899
3900 if (group != null) {
3901 rolePermissionsGroups.add(group);
3902 }
3903 }
3904 }
3905 }
3906
3907 groups.retainAll(rolePermissionsGroups);
3908 }
3909 }
3910
3911
3912
3913 Long roleId = (Long)params.remove("groupsRoles");
3914
3915 if (roleId != null) {
3916 groups.retainAll(rolePersistence.getGroups(roleId));
3917 }
3918
3919 if (userId == null) {
3920 return groups;
3921 }
3922
3923
3924
3925 Set<Group> joinedGroups = new HashSet<>(
3926 userPersistence.getGroups(userId));
3927
3928 boolean inherit = GetterUtil.getBoolean(params.remove("inherit"), true);
3929
3930 if (inherit) {
3931
3932
3933
3934 long[] organizationIds = userPersistence.getOrganizationPrimaryKeys(
3935 userId);
3936
3937 for (long organizationId : organizationIds) {
3938 for (Group group : groups) {
3939 if (organizationId == group.getClassPK()) {
3940 joinedGroups.add(group);
3941 }
3942 }
3943 }
3944
3945
3946
3947 for (long organizationId : organizationIds) {
3948 joinedGroups.addAll(
3949 organizationPersistence.getGroups(organizationId));
3950 }
3951
3952
3953
3954 long[] userGroupIds = userPersistence.getUserGroupPrimaryKeys(
3955 userId);
3956
3957 for (long userGroupId : userGroupIds) {
3958 joinedGroups.addAll(
3959 userGroupPersistence.getGroups(userGroupId));
3960 }
3961 }
3962
3963 if (_log.isDebugEnabled() && !params.isEmpty()) {
3964 _log.debug("Unprocessed parameters " + MapUtil.toString(params));
3965 }
3966
3967 if (joinedGroups.size() > groups.size()) {
3968 groups.retainAll(joinedGroups);
3969
3970 return groups;
3971 }
3972 else {
3973 joinedGroups.retainAll(groups);
3974
3975 return joinedGroups;
3976 }
3977 }
3978
3979 protected long[] getClassNameIds() {
3980 if (_classNameIds == null) {
3981 _classNameIds = new long[] {
3982 classNameLocalService.getClassNameId(Group.class),
3983 classNameLocalService.getClassNameId(Organization.class)
3984 };
3985 }
3986
3987 return _classNameIds;
3988 }
3989
3990 protected String getFriendlyURL(
3991 long companyId, long groupId, long classNameId, long classPK,
3992 String friendlyName, String friendlyURL)
3993 throws PortalException {
3994
3995 friendlyURL = getFriendlyURL(friendlyURL);
3996
3997 if (Validator.isNotNull(friendlyURL)) {
3998 return friendlyURL;
3999 }
4000
4001 friendlyURL = StringPool.SLASH + getFriendlyURL(friendlyName);
4002
4003 String originalFriendlyURL = friendlyURL;
4004
4005 for (int i = 1;; i++) {
4006 try {
4007 validateFriendlyURL(
4008 companyId, groupId, classNameId, classPK, friendlyURL);
4009
4010 break;
4011 }
4012 catch (GroupFriendlyURLException gfurle) {
4013 int type = gfurle.getType();
4014
4015 if (type == GroupFriendlyURLException.DUPLICATE) {
4016 friendlyURL = originalFriendlyURL + i;
4017 }
4018 else {
4019 friendlyURL = StringPool.SLASH + classPK;
4020
4021 break;
4022 }
4023 }
4024 }
4025
4026 return friendlyURL;
4027 }
4028
4029 protected String getFriendlyURL(String friendlyURL) {
4030 return FriendlyURLNormalizerUtil.normalize(friendlyURL);
4031 }
4032
4033 protected String getOrgGroupName(String name) {
4034 return name + ORGANIZATION_NAME_SUFFIX;
4035 }
4036
4037 protected List<PortletDataHandler> getPortletDataHandlers(Group group) {
4038 List<Portlet> portlets = portletLocalService.getPortlets(
4039 group.getCompanyId());
4040
4041 List<PortletDataHandler> portletDataHandlers = new ArrayList<>(
4042 portlets.size());
4043
4044 for (Portlet portlet : portlets) {
4045 if (!portlet.isActive()) {
4046 continue;
4047 }
4048
4049 PortletDataHandler portletDataHandler =
4050 portlet.getPortletDataHandlerInstance();
4051
4052 if ((portletDataHandler != null) &&
4053 !portletDataHandler.isDataPortalLevel()) {
4054
4055 portletDataHandlers.add(portletDataHandler);
4056 }
4057 }
4058
4059 return portletDataHandlers;
4060 }
4061
4062 protected String[] getSearchNames(long companyId, String name) {
4063 if (Validator.isNull(name)) {
4064 return new String[] {null};
4065 }
4066
4067 Company company = companyPersistence.fetchByPrimaryKey(companyId);
4068
4069 if (company == null) {
4070 return CustomSQLUtil.keywords(name);
4071 }
4072
4073 Account account = accountPersistence.fetchByPrimaryKey(
4074 company.getAccountId());
4075
4076 if (account == null) {
4077 return CustomSQLUtil.keywords(name);
4078 }
4079
4080 String companyName = account.getName();
4081
4082 if (StringUtil.wildcardMatches(
4083 companyName, name, CharPool.UNDERLINE, CharPool.PERCENT,
4084 CharPool.BACK_SLASH, false)) {
4085
4086 String[] searchNames = CustomSQLUtil.keywords(name);
4087
4088 String guestName = StringUtil.quote(
4089 StringUtil.toLowerCase(GroupConstants.GUEST),
4090 StringPool.PERCENT);
4091
4092 return ArrayUtil.append(searchNames, guestName);
4093 }
4094
4095 return CustomSQLUtil.keywords(name);
4096 }
4097
4098 protected void initImportLARFile() {
4099 String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
4100
4101 if (_log.isDebugEnabled()) {
4102 _log.debug("Reading public LAR file " + publicLARFileName);
4103 }
4104
4105 if (Validator.isNotNull(publicLARFileName)) {
4106 publicLARFile = new File(publicLARFileName);
4107
4108 if (!publicLARFile.exists()) {
4109 _log.error(
4110 "Public LAR file " + publicLARFile + " does not exist");
4111
4112 publicLARFile = null;
4113 }
4114 else {
4115 if (_log.isDebugEnabled()) {
4116 _log.debug("Using public LAR file " + publicLARFileName);
4117 }
4118 }
4119 }
4120 }
4121
4122 protected void initUserPersonalSitePermissions(Group group)
4123 throws PortalException {
4124
4125
4126
4127 Role role = roleLocalService.getRole(
4128 group.getCompanyId(), RoleConstants.USER);
4129
4130 setRolePermissions(
4131 group, role, Layout.class.getName(),
4132 new String[] {ActionKeys.VIEW});
4133
4134 setRolePermissions(
4135 group, role, "com.liferay.portlet.blogs",
4136 new String[] {
4137 ActionKeys.ADD_ENTRY, ActionKeys.PERMISSIONS,
4138 ActionKeys.SUBSCRIBE
4139 });
4140
4141
4142
4143 role = roleLocalService.getRole(
4144 group.getCompanyId(), RoleConstants.POWER_USER);
4145
4146 List<Portlet> portlets = portletLocalService.getPortlets(
4147 group.getCompanyId(), false, false);
4148
4149 for (Portlet portlet : portlets) {
4150 List<String> actions =
4151 ResourceActionsUtil.getPortletResourceActions(
4152 portlet.getPortletId());
4153
4154 String controlPanelEntryCategory = GetterUtil.getString(
4155 portlet.getControlPanelEntryCategory());
4156
4157 if (actions.contains(ActionKeys.ACCESS_IN_CONTROL_PANEL) &&
4158 controlPanelEntryCategory.startsWith(
4159 PortletCategoryKeys.SITE_ADMINISTRATION)) {
4160
4161 setRolePermissions(
4162 group, role, portlet.getPortletId(),
4163 new String[] {ActionKeys.ACCESS_IN_CONTROL_PANEL});
4164 }
4165 }
4166
4167 setRolePermissions(
4168 group, role, Group.class.getName(),
4169 new String[] {
4170 ActionKeys.MANAGE_LAYOUTS, ActionKeys.VIEW_SITE_ADMINISTRATION
4171 });
4172
4173 setRolePermissions(group, role, "com.liferay.portlet.asset");
4174 setRolePermissions(group, role, "com.liferay.portlet.blogs");
4175 setRolePermissions(group, role, "com.liferay.portlet.bookmarks");
4176 setRolePermissions(group, role, "com.liferay.portlet.documentlibrary");
4177 setRolePermissions(group, role, "com.liferay.portlet.imagegallery");
4178 setRolePermissions(group, role, "com.liferay.portlet.journal");
4179 setRolePermissions(group, role, "com.liferay.portlet.messageboards");
4180 setRolePermissions(group, role, "com.liferay.portlet.wiki");
4181 }
4182
4183 protected boolean isParentGroup(long parentGroupId, long groupId)
4184 throws PortalException {
4185
4186
4187
4188 if (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4189 return false;
4190 }
4191
4192 Group group = groupPersistence.findByPrimaryKey(groupId);
4193
4194 String treePath = group.getTreePath();
4195
4196 if (treePath.contains(
4197 StringPool.SLASH + parentGroupId + StringPool.SLASH)) {
4198
4199 return true;
4200 }
4201 else {
4202 return false;
4203 }
4204 }
4205
4206 protected boolean isStaging(ServiceContext serviceContext) {
4207 if (serviceContext != null) {
4208 return ParamUtil.getBoolean(serviceContext, "staging");
4209 }
4210
4211 return false;
4212 }
4213
4214 protected boolean isUseComplexSQL(long[] classNameIds) {
4215 if (ArrayUtil.isEmpty(classNameIds)) {
4216 return true;
4217 }
4218
4219 if (_complexSQLClassNameIds == null) {
4220 String[] complexSQLClassNames =
4221 PropsValues.GROUPS_COMPLEX_SQL_CLASS_NAMES;
4222
4223 long[] complexSQLClassNameIds =
4224 new long[complexSQLClassNames.length];
4225
4226 for (int i = 0; i < complexSQLClassNames.length; i++) {
4227 String complexSQLClassName = complexSQLClassNames[i];
4228
4229 complexSQLClassNameIds[i] =
4230 classNameLocalService.getClassNameId(complexSQLClassName);
4231 }
4232
4233 _complexSQLClassNameIds = complexSQLClassNameIds;
4234 }
4235
4236 for (long classNameId : classNameIds) {
4237 if (ArrayUtil.contains(_complexSQLClassNameIds, classNameId)) {
4238 return true;
4239 }
4240 }
4241
4242 return false;
4243 }
4244
4245 protected boolean matches(String s, String[] keywords) {
4246 if ((keywords == null) ||
4247 ((keywords.length == 1) && (keywords[0] == null))) {
4248
4249 return true;
4250 }
4251
4252 for (String keyword : keywords) {
4253 if (StringUtil.wildcardMatches(
4254 s, keyword, CharPool.UNDERLINE, CharPool.PERCENT,
4255 CharPool.BACK_SLASH, false)) {
4256
4257 return true;
4258 }
4259 }
4260
4261 return false;
4262 }
4263
4264 protected void setCompanyPermissions(
4265 Role role, String name, String[] actionIds)
4266 throws PortalException {
4267
4268 if (resourceBlockLocalService.isSupported(name)) {
4269 resourceBlockLocalService.setCompanyScopePermissions(
4270 role.getCompanyId(), name, role.getRoleId(),
4271 Arrays.asList(actionIds));
4272 }
4273 else {
4274 resourcePermissionLocalService.setResourcePermissions(
4275 role.getCompanyId(), name, ResourceConstants.SCOPE_COMPANY,
4276 String.valueOf(role.getCompanyId()), role.getRoleId(),
4277 actionIds);
4278 }
4279 }
4280
4281 protected void setRolePermissions(Group group, Role role, String name)
4282 throws PortalException {
4283
4284 List<String> actions = ResourceActionsUtil.getModelResourceActions(
4285 name);
4286
4287 setRolePermissions(
4288 group, role, name, actions.toArray(new String[actions.size()]));
4289 }
4290
4291 protected void setRolePermissions(
4292 Group group, Role role, String name, String[] actionIds)
4293 throws PortalException {
4294
4295 if (resourceBlockLocalService.isSupported(name)) {
4296 resourceBlockLocalService.setGroupScopePermissions(
4297 role.getCompanyId(), group.getGroupId(), name, role.getRoleId(),
4298 Arrays.asList(actionIds));
4299 }
4300 else {
4301 resourcePermissionLocalService.setResourcePermissions(
4302 group.getCompanyId(), name, ResourceConstants.SCOPE_GROUP,
4303 String.valueOf(group.getGroupId()), role.getRoleId(),
4304 actionIds);
4305 }
4306 }
4307
4308 protected List<Group> sort(
4309 Collection<Group> groups, int start, int end,
4310 OrderByComparator<Group> obc) {
4311
4312 if (obc == null) {
4313 obc = new GroupNameComparator(true);
4314 }
4315
4316 List<Group> groupList = null;
4317
4318 if (groups instanceof List) {
4319 groupList = (List<Group>)groups;
4320 }
4321 else {
4322 groupList = new ArrayList<>(groups);
4323 }
4324
4325 Collections.sort(groupList, obc);
4326
4327 return Collections.unmodifiableList(
4328 ListUtil.subList(groupList, start, end));
4329 }
4330
4331 protected void unscheduleStaging(Group group) {
4332 try {
4333
4334
4335
4336 String groupName = StagingUtil.getSchedulerGroupName(
4337 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
4338
4339 SchedulerEngineHelperUtil.delete(groupName, StorageType.PERSISTED);
4340
4341 long liveGroupId = 0;
4342 long stagingGroupId = 0;
4343
4344 if (group.isStagingGroup()) {
4345 liveGroupId = group.getLiveGroupId();
4346
4347 stagingGroupId = group.getGroupId();
4348 }
4349 else if (group.hasStagingGroup()) {
4350 liveGroupId = group.getGroupId();
4351
4352 stagingGroupId = group.getStagingGroup().getGroupId();
4353 }
4354
4355 if ((liveGroupId != 0) && (stagingGroupId != 0)) {
4356
4357
4358
4359 groupName = StagingUtil.getSchedulerGroupName(
4360 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
4361
4362 SchedulerEngineHelperUtil.delete(
4363 groupName, StorageType.PERSISTED);
4364
4365
4366
4367 groupName = StagingUtil.getSchedulerGroupName(
4368 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
4369
4370 SchedulerEngineHelperUtil.delete(
4371 groupName, StorageType.PERSISTED);
4372 }
4373 }
4374 catch (Exception e) {
4375 _log.error(
4376 "Unable to unschedule events for group: " + group.getGroupId());
4377 }
4378 }
4379
4380 protected void validateFriendlyURL(
4381 long companyId, long groupId, long classNameId, long classPK,
4382 String friendlyURL)
4383 throws PortalException {
4384
4385 Company company = companyPersistence.findByPrimaryKey(companyId);
4386
4387 if (company.isSystem()) {
4388 return;
4389 }
4390
4391 if (Validator.isNull(friendlyURL)) {
4392 return;
4393 }
4394
4395 int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
4396
4397 if (exceptionType != -1) {
4398 throw new GroupFriendlyURLException(exceptionType);
4399 }
4400
4401 Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
4402
4403 if ((group != null) && (group.getGroupId() != groupId)) {
4404 GroupFriendlyURLException gfurle = new GroupFriendlyURLException(
4405 GroupFriendlyURLException.DUPLICATE);
4406
4407 gfurle.setDuplicateClassPK(group.getGroupId());
4408 gfurle.setDuplicateClassName(Group.class.getName());
4409
4410 throw gfurle;
4411 }
4412
4413 String groupIdFriendlyURL = friendlyURL.substring(1);
4414
4415 if (Validator.isNumber(groupIdFriendlyURL)) {
4416 long groupClassNameId = classNameLocalService.getClassNameId(
4417 Group.class);
4418
4419 if (((classNameId != groupClassNameId) &&
4420 !groupIdFriendlyURL.equals(String.valueOf(classPK)) &&
4421 !PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC) ||
4422 ((classNameId == groupClassNameId) &&
4423 !groupIdFriendlyURL.equals(String.valueOf(groupId)))) {
4424
4425 GroupFriendlyURLException gfurle =
4426 new GroupFriendlyURLException(
4427 GroupFriendlyURLException.POSSIBLE_DUPLICATE);
4428
4429 gfurle.setKeywordConflict(groupIdFriendlyURL);
4430
4431 throw gfurle;
4432 }
4433 }
4434
4435 String screenName = friendlyURL.substring(1);
4436
4437 User user = userPersistence.fetchByC_SN(companyId, screenName);
4438
4439 if (user != null) {
4440 long userClassNameId = classNameLocalService.getClassNameId(
4441 User.class);
4442
4443 if ((classNameId == userClassNameId) &&
4444 (classPK == user.getUserId())) {
4445 }
4446 else {
4447 GroupFriendlyURLException gfurle =
4448 new GroupFriendlyURLException(
4449 GroupFriendlyURLException.DUPLICATE);
4450
4451 gfurle.setDuplicateClassPK(user.getUserId());
4452 gfurle.setDuplicateClassName(User.class.getName());
4453
4454 throw gfurle;
4455 }
4456 }
4457
4458 if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
4459 throw new GroupFriendlyURLException(
4460 GroupFriendlyURLException.TOO_DEEP);
4461 }
4462 }
4463
4464 protected void validateGroupKey(
4465 long groupId, long companyId, String groupKey, boolean site)
4466 throws PortalException {
4467
4468 if (Validator.isNull(groupKey) || Validator.isNumber(groupKey) ||
4469 groupKey.contains(StringPool.STAR) ||
4470 groupKey.contains(ORGANIZATION_NAME_SUFFIX)) {
4471
4472 throw new GroupKeyException();
4473 }
4474
4475 try {
4476 Group group = groupFinder.findByC_GK(companyId, groupKey);
4477
4478 if ((groupId <= 0) || (group.getGroupId() != groupId)) {
4479 throw new DuplicateGroupException("{groupId=" + groupId + "}");
4480 }
4481 }
4482 catch (NoSuchGroupException nsge) {
4483 }
4484
4485 if (site) {
4486 Company company = companyLocalService.getCompany(companyId);
4487
4488 if (groupKey.equals(company.getName())) {
4489 throw new DuplicateGroupException();
4490 }
4491 }
4492 }
4493
4494 protected void validateInheritContent(
4495 long parentGroupId, boolean inheritContent)
4496 throws GroupInheritContentException {
4497
4498 if (!inheritContent) {
4499 return;
4500 }
4501
4502 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4503 throw new GroupInheritContentException();
4504 }
4505
4506 Group parentGroup = groupPersistence.fetchByPrimaryKey(parentGroupId);
4507
4508 if (parentGroup.isInheritContent()) {
4509 throw new GroupInheritContentException();
4510 }
4511 }
4512
4513 protected void validateLanguageIds(
4514 String defaultLanguageId, String languageIds)
4515 throws PortalException {
4516
4517 String[] languageIdsArray = StringUtil.split(languageIds);
4518
4519 for (String languageId : languageIdsArray) {
4520 if (!LanguageUtil.isAvailableLocale(
4521 LocaleUtil.fromLanguageId(languageId))) {
4522
4523 LocaleException le = new LocaleException(
4524 LocaleException.TYPE_DISPLAY_SETTINGS);
4525
4526 le.setSourceAvailableLocales(
4527 LanguageUtil.getAvailableLocales());
4528 le.setTargetAvailableLocales(
4529 Arrays.asList(
4530 LocaleUtil.fromLanguageIds(languageIdsArray)));
4531
4532 throw le;
4533 }
4534 }
4535
4536 if (!ArrayUtil.contains(languageIdsArray, defaultLanguageId)) {
4537 LocaleException le = new LocaleException(
4538 LocaleException.TYPE_DEFAULT);
4539
4540 le.setSourceAvailableLocales(LanguageUtil.getAvailableLocales());
4541 le.setTargetAvailableLocales(
4542 Arrays.asList(LocaleUtil.fromLanguageIds(languageIdsArray)));
4543
4544 throw le;
4545 }
4546 }
4547
4548 protected void validateParentGroup(long groupId, long parentGroupId)
4549 throws PortalException {
4550
4551 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4552 return;
4553 }
4554
4555 if (groupId == parentGroupId) {
4556 throw new GroupParentException.MustNotBeOwnParent(groupId);
4557 }
4558
4559 Group group = groupPersistence.fetchByPrimaryKey(groupId);
4560
4561 if (group == null) {
4562 return;
4563 }
4564
4565 if ((groupId > 0) &&
4566 (parentGroupId != GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
4567
4568
4569
4570 if (isParentGroup(groupId, parentGroupId)) {
4571 throw new GroupParentException.MustNotHaveChildParent(
4572 groupId, parentGroupId);
4573 }
4574 }
4575
4576 Group parentGroup = groupPersistence.findByPrimaryKey(parentGroupId);
4577
4578 if (group.isStagingGroup()) {
4579 long stagingGroupId = parentGroup.getStagingGroup().getGroupId();
4580
4581 if (groupId == stagingGroupId) {
4582 throw new GroupParentException.MustNotHaveStagingParent(
4583 groupId, stagingGroupId);
4584 }
4585 }
4586 }
4587
4588 protected File publicLARFile;
4589
4590 private static final Log _log = LogFactoryUtil.getLog(
4591 GroupLocalServiceImpl.class);
4592
4593 private volatile long[] _classNameIds;
4594 private volatile long[] _complexSQLClassNameIds;
4595 private final Map<String, Group> _systemGroupsMap = new HashMap<>();
4596
4597 }