001
014
015 package com.liferay.portal.service.impl;
016
017 import com.liferay.portal.LocaleException;
018 import com.liferay.portal.exception.DuplicateGroupException;
019 import com.liferay.portal.exception.GroupFriendlyURLException;
020 import com.liferay.portal.exception.GroupInheritContentException;
021 import com.liferay.portal.exception.GroupKeyException;
022 import com.liferay.portal.exception.GroupParentException;
023 import com.liferay.portal.exception.NoSuchGroupException;
024 import com.liferay.portal.exception.NoSuchLayoutSetException;
025 import com.liferay.portal.exception.PendingBackgroundTaskException;
026 import com.liferay.portal.exception.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.security.auth.CompanyThreadLocal;
041 import com.liferay.portal.kernel.security.permission.ActionKeys;
042 import com.liferay.portal.kernel.security.permission.ResourceActionsUtil;
043 import com.liferay.portal.kernel.security.permission.RolePermissions;
044 import com.liferay.portal.kernel.spring.aop.Skip;
045 import com.liferay.portal.kernel.transaction.Propagation;
046 import com.liferay.portal.kernel.transaction.Transactional;
047 import com.liferay.portal.kernel.util.ArrayUtil;
048 import com.liferay.portal.kernel.util.CharPool;
049 import com.liferay.portal.kernel.util.FileUtil;
050 import com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil;
051 import com.liferay.portal.kernel.util.GetterUtil;
052 import com.liferay.portal.kernel.util.GroupThreadLocal;
053 import com.liferay.portal.kernel.util.ListUtil;
054 import com.liferay.portal.kernel.util.LocaleUtil;
055 import com.liferay.portal.kernel.util.MapUtil;
056 import com.liferay.portal.kernel.util.OrderByComparator;
057 import com.liferay.portal.kernel.util.ParamUtil;
058 import com.liferay.portal.kernel.util.PropsKeys;
059 import com.liferay.portal.kernel.util.StringBundler;
060 import com.liferay.portal.kernel.util.StringPool;
061 import com.liferay.portal.kernel.util.StringUtil;
062 import com.liferay.portal.kernel.util.TreeModelTasksAdapter;
063 import com.liferay.portal.kernel.util.TreePathUtil;
064 import com.liferay.portal.kernel.util.UnicodeProperties;
065 import com.liferay.portal.kernel.util.Validator;
066 import com.liferay.portal.kernel.workflow.WorkflowHandler;
067 import com.liferay.portal.kernel.workflow.WorkflowHandlerRegistryUtil;
068 import com.liferay.portal.model.Account;
069 import com.liferay.portal.model.Company;
070 import com.liferay.portal.model.Group;
071 import com.liferay.portal.model.GroupConstants;
072 import com.liferay.portal.model.Layout;
073 import com.liferay.portal.model.LayoutConstants;
074 import com.liferay.portal.model.LayoutPrototype;
075 import com.liferay.portal.model.LayoutSet;
076 import com.liferay.portal.model.LayoutSetPrototype;
077 import com.liferay.portal.model.LayoutTemplate;
078 import com.liferay.portal.model.LayoutTypePortlet;
079 import com.liferay.portal.model.Organization;
080 import com.liferay.portal.model.Portlet;
081 import com.liferay.portal.model.ResourceAction;
082 import com.liferay.portal.model.ResourceConstants;
083 import com.liferay.portal.model.ResourcePermission;
084 import com.liferay.portal.model.ResourceTypePermission;
085 import com.liferay.portal.model.Role;
086 import com.liferay.portal.model.RoleConstants;
087 import com.liferay.portal.model.User;
088 import com.liferay.portal.model.UserGroup;
089 import com.liferay.portal.model.UserGroupRole;
090 import com.liferay.portal.model.UserPersonalSite;
091 import com.liferay.portal.model.WorkflowDefinitionLink;
092 import com.liferay.portal.model.impl.LayoutImpl;
093 import com.liferay.portal.security.permission.PermissionCacheUtil;
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 groupKey.equals(GroupConstants.FORMS))) {
313
314 throw new IllegalArgumentException();
315 }
316 }
317 else if (!className.equals(Company.class.getName()) &&
318 !className.equals(Organization.class.getName()) &&
319 className.startsWith("com.liferay.portal.model.")) {
320
321 if (site) {
322 throw new IllegalArgumentException();
323 }
324 }
325
326 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
327 validateGroupKey(groupId, user.getCompanyId(), groupKey, site);
328 }
329
330 validateInheritContent(parentGroupId, inheritContent);
331
332 validateFriendlyURL(
333 user.getCompanyId(), groupId, classNameId, classPK, friendlyURL);
334
335 validateParentGroup(groupId, parentGroupId);
336
337 Group group = groupPersistence.create(groupId);
338
339 if (serviceContext != null) {
340 group.setUuid(serviceContext.getUuid());
341 }
342
343 group.setCompanyId(user.getCompanyId());
344 group.setCreatorUserId(userId);
345 group.setClassNameId(classNameId);
346 group.setClassPK(classPK);
347 group.setParentGroupId(parentGroupId);
348 group.setLiveGroupId(liveGroupId);
349 group.setTreePath(group.buildTreePath());
350 group.setGroupKey(groupKey);
351 group.setNameMap(nameMap);
352 group.setDescriptionMap(descriptionMap);
353 group.setType(type);
354 group.setManualMembership(manualMembership);
355 group.setMembershipRestriction(membershipRestriction);
356 group.setFriendlyURL(friendlyURL);
357 group.setInheritContent(inheritContent);
358 group.setSite(site);
359 group.setActive(active);
360
361 if ((serviceContext != null) && (classNameId == groupClassNameId) &&
362 !user.isDefaultUser()) {
363
364 group.setExpandoBridgeAttributes(serviceContext);
365 }
366
367 groupPersistence.update(group);
368
369
370
371 layoutSetLocalService.addLayoutSet(groupId, true);
372
373 layoutSetLocalService.addLayoutSet(groupId, false);
374
375
376
377 resourceLocalService.addResources(
378 group.getCompanyId(), 0, 0, Group.class.getName(),
379 group.getGroupId(), false, false, false);
380
381 if ((classNameId == groupClassNameId) && !user.isDefaultUser()) {
382
383
384
385 Role role = roleLocalService.getRole(
386 group.getCompanyId(), RoleConstants.SITE_OWNER);
387
388 userGroupRoleLocalService.addUserGroupRoles(
389 userId, groupId, new long[] {role.getRoleId()});
390
391
392
393 userLocalService.addGroupUsers(
394 group.getGroupId(), new long[] {userId});
395
396
397
398 if (serviceContext != null) {
399 updateAsset(
400 userId, group, serviceContext.getAssetCategoryIds(),
401 serviceContext.getAssetTagNames());
402 }
403 }
404
405 addPortletDefaultData(group);
406
407 return group;
408 }
409
410 @Override
411 public Group addGroup(
412 long userId, long parentGroupId, String className, long classPK,
413 long liveGroupId, Map<Locale, String> nameMap,
414 Map<Locale, String> descriptionMap, int type,
415 boolean manualMembership, int membershipRestriction,
416 String friendlyURL, boolean site, boolean active,
417 ServiceContext serviceContext)
418 throws PortalException {
419
420 return addGroup(
421 userId, parentGroupId, className, classPK, liveGroupId, nameMap,
422 descriptionMap, type, manualMembership, membershipRestriction,
423 friendlyURL, site, false, active, serviceContext);
424 }
425
426
456 @Deprecated
457 @Override
458 public Group addGroup(
459 long userId, long parentGroupId, String className, long classPK,
460 long liveGroupId, String name, String description, int type,
461 boolean manualMembership, int membershipRestriction,
462 String friendlyURL, boolean site, boolean active,
463 ServiceContext serviceContext)
464 throws PortalException {
465
466 return addGroup(
467 userId, parentGroupId, className, classPK, liveGroupId,
468 getLocalizationMap(name), getLocalizationMap(description), type,
469 manualMembership, membershipRestriction, friendlyURL, site, false,
470 active, serviceContext);
471 }
472
473
479 @Override
480 public void addRoleGroups(long roleId, long[] groupIds) {
481 rolePersistence.addGroups(roleId, groupIds);
482
483 PermissionCacheUtil.clearCache();
484 }
485
486
492 @Override
493 public void addUserGroups(long userId, long[] groupIds) {
494 userPersistence.addGroups(userId, groupIds);
495
496 PermissionCacheUtil.clearCache(userId);
497 }
498
499
506 @Override
507 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
508 public void checkCompanyGroup(long companyId) throws PortalException {
509 long classNameId = classNameLocalService.getClassNameId(Company.class);
510
511 int count = groupPersistence.countByC_C_C(
512 companyId, classNameId, companyId);
513
514 if (count == 0) {
515 long defaultUserId = userLocalService.getDefaultUserId(companyId);
516
517 groupLocalService.addGroup(
518 defaultUserId, GroupConstants.DEFAULT_PARENT_GROUP_ID,
519 Company.class.getName(), companyId,
520 GroupConstants.DEFAULT_LIVE_GROUP_ID,
521 getLocalizationMap(GroupConstants.GLOBAL), null, 0, true,
522 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION,
523 GroupConstants.GLOBAL_FRIENDLY_URL, true, true, null);
524 }
525 }
526
527 @Override
528 public Group checkScopeGroup(Layout layout, long userId)
529 throws PortalException {
530
531 if (layout.hasScopeGroup()) {
532 return layout.getScopeGroup();
533 }
534
535 Map<Locale, String> nameMap = new HashMap<>();
536
537 nameMap.put(LocaleUtil.getDefault(), String.valueOf(layout.getPlid()));
538
539 Group scopeGroup = groupLocalService.addGroup(
540 userId, GroupConstants.DEFAULT_PARENT_GROUP_ID,
541 Layout.class.getName(), layout.getPlid(),
542 GroupConstants.DEFAULT_LIVE_GROUP_ID, nameMap, null, 0, true,
543 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, null, false, true,
544 null);
545
546 return scopeGroup;
547 }
548
549
557 @Override
558 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
559 public void checkSystemGroups(long companyId) throws PortalException {
560 String companyIdHexString = StringUtil.toHexString(companyId);
561
562 for (Group group : groupFinder.findBySystem(companyId)) {
563 _systemGroupsMap.put(
564 companyIdHexString.concat(group.getGroupKey()), group);
565 }
566
567 long defaultUserId = userLocalService.getDefaultUserId(companyId);
568
569 String[] systemGroups = PortalUtil.getSystemGroups();
570
571 for (String groupKey : systemGroups) {
572 String groupCacheKey = companyIdHexString.concat(groupKey);
573
574 Group group = _systemGroupsMap.get(groupCacheKey);
575
576 if (group == null) {
577 group = groupPersistence.fetchByC_GK(companyId, groupKey);
578 }
579
580 if (group == null) {
581 String className = null;
582 long classPK = 0;
583 int type = GroupConstants.TYPE_SITE_OPEN;
584 String friendlyURL = null;
585 boolean site = true;
586
587 if (groupKey.equals(GroupConstants.CONTROL_PANEL)) {
588 type = GroupConstants.TYPE_SITE_PRIVATE;
589 friendlyURL = GroupConstants.CONTROL_PANEL_FRIENDLY_URL;
590 site = false;
591 }
592 else if (groupKey.equals(GroupConstants.FORMS)) {
593 type = GroupConstants.TYPE_SITE_PRIVATE;
594 friendlyURL = GroupConstants.FORMS_FRIENDLY_URL;
595 site = false;
596 }
597 else if (groupKey.equals(GroupConstants.GUEST)) {
598 friendlyURL = "/guest";
599 }
600 else if (groupKey.equals(GroupConstants.USER_PERSONAL_SITE)) {
601 className = UserPersonalSite.class.getName();
602 classPK = defaultUserId;
603 type = GroupConstants.TYPE_SITE_PRIVATE;
604 friendlyURL =
605 GroupConstants.USER_PERSONAL_SITE_FRIENDLY_URL;
606 site = false;
607 }
608
609 group = groupLocalService.addGroup(
610 defaultUserId, GroupConstants.DEFAULT_PARENT_GROUP_ID,
611 className, classPK, GroupConstants.DEFAULT_LIVE_GROUP_ID,
612 getLocalizationMap(groupKey), null, type, true,
613 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL,
614 site, true, null);
615
616 if (groupKey.equals(GroupConstants.USER_PERSONAL_SITE)) {
617 initUserPersonalSitePermissions(group);
618 }
619 }
620
621 if (group.isControlPanel()) {
622 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
623 group.getGroupId(), true);
624
625 if (layoutSet.getPageCount() == 0) {
626 addControlPanelLayouts(group);
627 }
628 }
629
630 if (group.isGuest()) {
631 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
632 group.getGroupId(), false);
633
634 if (layoutSet.getPageCount() == 0) {
635 addDefaultGuestPublicLayouts(group);
636 }
637 }
638
639 _systemGroupsMap.put(groupCacheKey, group);
640 }
641 }
642
643
657 @Override
658 public Group deleteGroup(Group group) throws PortalException {
659 boolean deleteInProcess = GroupThreadLocal.isDeleteInProcess();
660
661 try {
662 GroupThreadLocal.setDeleteInProcess(true);
663
664 if (((group.isCompany() && !group.isCompanyStagingGroup()) ||
665 PortalUtil.isSystemGroup(group.getGroupKey())) &&
666 !CompanyThreadLocal.isDeleteInProcess()) {
667
668 throw new RequiredGroupException.MustNotDeleteSystemGroup(
669 group.getGroupId());
670 }
671
672 if (groupPersistence.countByC_P_S(
673 group.getCompanyId(), group.getGroupId(), true) > 0) {
674
675 throw new RequiredGroupException.MustNotDeleteGroupThatHasChild(
676 group.getGroupId());
677 }
678
679 List<BackgroundTask> backgroundTasks =
680 BackgroundTaskManagerUtil.getBackgroundTasks(
681 group.getGroupId(),
682 BackgroundTaskConstants.STATUS_IN_PROGRESS);
683
684 if (!backgroundTasks.isEmpty()) {
685 throw new PendingBackgroundTaskException(
686 "Unable to delete group with pending background tasks");
687 }
688
689
690
691 BackgroundTaskManagerUtil.deleteGroupBackgroundTasks(
692 group.getGroupId());
693
694
695
696 layoutSetBranchLocalService.deleteLayoutSetBranches(
697 group.getGroupId(), true, true);
698
699 layoutSetBranchLocalService.deleteLayoutSetBranches(
700 group.getGroupId(), false, true);
701
702
703
704 ServiceContext serviceContext = new ServiceContext();
705
706 try {
707 layoutSetLocalService.deleteLayoutSet(
708 group.getGroupId(), true, serviceContext);
709 }
710 catch (NoSuchLayoutSetException nslse) {
711 }
712
713 try {
714 layoutSetLocalService.deleteLayoutSet(
715 group.getGroupId(), false, serviceContext);
716 }
717 catch (NoSuchLayoutSetException nslse) {
718 }
719
720
721
722 membershipRequestLocalService.deleteMembershipRequests(
723 group.getGroupId());
724
725
726
727 portletPreferencesLocalService.deletePortletPreferences(
728 group.getGroupId(), PortletKeys.PREFS_OWNER_TYPE_GROUP,
729 PortletKeys.PREFS_PLID_SHARED);
730
731
732
733 dlAppLocalService.deleteAllRepositories(group.getGroupId());
734
735
736
737 teamLocalService.deleteTeams(group.getGroupId());
738
739
740
741 exportImportConfigurationLocalService.
742 deleteExportImportConfigurations(group.getGroupId());
743
744 unscheduleStaging(group);
745
746 if (group.hasStagingGroup()) {
747 try {
748 stagingLocalService.disableStaging(group, serviceContext);
749 }
750 catch (Exception e) {
751 _log.error(
752 "Unable to disable staging for group " +
753 group.getGroupId());
754 }
755 }
756
757
758
759 ThemeLoader themeLoader =
760 ThemeLoaderFactory.getDefaultThemeLoader();
761
762 if (themeLoader != null) {
763 String themePath =
764 themeLoader.getFileStorage() + StringPool.SLASH +
765 group.getGroupId();
766
767 FileUtil.deltree(themePath + "-private");
768 FileUtil.deltree(themePath + "-public");
769 }
770
771
772
773 deletePortletData(group);
774
775
776
777 if (group.isRegularSite()) {
778 assetEntryLocalService.deleteEntry(
779 Group.class.getName(), group.getGroupId());
780 }
781
782 assetEntryLocalService.deleteGroupEntries(group.getGroupId());
783
784 assetTagLocalService.deleteGroupTags(group.getGroupId());
785
786 assetVocabularyLocalService.deleteVocabularies(group.getGroupId());
787
788
789
790 expandoRowLocalService.deleteRows(group.getGroupId());
791
792
793
794 socialActivityLocalService.deleteActivities(group.getGroupId());
795 socialActivitySettingLocalService.deleteActivitySettings(
796 group.getGroupId());
797 socialRequestLocalService.deleteRequests(
798 classNameLocalService.getClassNameId(Group.class),
799 group.getGroupId());
800
801
802
803 List<ResourcePermission> resourcePermissions =
804 resourcePermissionPersistence.findByC_LikeP(
805 group.getCompanyId(), String.valueOf(group.getGroupId()));
806
807 for (ResourcePermission resourcePermission : resourcePermissions) {
808 resourcePermissionLocalService.deleteResourcePermission(
809 resourcePermission);
810 }
811
812 if (!group.isStagingGroup() &&
813 (group.isOrganization() || group.isRegularSite())) {
814
815 resourceLocalService.deleteResource(
816 group.getCompanyId(), Group.class.getName(),
817 ResourceConstants.SCOPE_INDIVIDUAL, group.getGroupId());
818 }
819
820
821
822 trashEntryLocalService.deleteEntries(group.getGroupId());
823
824
825
826 List<WorkflowHandler<?>> scopeableWorkflowHandlers =
827 WorkflowHandlerRegistryUtil.getScopeableWorkflowHandlers();
828
829 for (WorkflowHandler<?> scopeableWorkflowHandler :
830 scopeableWorkflowHandlers) {
831
832 if (!scopeableWorkflowHandler.isVisible()) {
833 continue;
834 }
835
836 WorkflowDefinitionLink workflowDefinitionLink =
837 workflowDefinitionLinkLocalService.
838 fetchWorkflowDefinitionLink(
839 group.getCompanyId(), group.getGroupId(),
840 scopeableWorkflowHandler.getClassName(), 0, 0,
841 true);
842
843 if (workflowDefinitionLink == null) {
844 continue;
845 }
846
847 workflowDefinitionLinkLocalService.deleteWorkflowDefinitionLink(
848 workflowDefinitionLink);
849 }
850
851
852
853 if (!group.isStagingGroup() && group.isOrganization() &&
854 group.isSite()) {
855
856 group.setSite(false);
857
858 groupPersistence.update(group);
859
860
861
862 userGroupRoleLocalService.deleteUserGroupRoles(
863 group.getGroupId(), RoleConstants.TYPE_SITE);
864
865
866
867 userGroupGroupRoleLocalService.deleteUserGroupGroupRoles(
868 group.getGroupId(), RoleConstants.TYPE_SITE);
869 }
870 else {
871 groupPersistence.remove(group);
872
873
874
875 userGroupRoleLocalService.deleteUserGroupRolesByGroupId(
876 group.getGroupId());
877
878
879
880 userGroupGroupRoleLocalService.
881 deleteUserGroupGroupRolesByGroupId(group.getGroupId());
882 }
883
884
885
886 PermissionCacheUtil.clearCache();
887
888 return group;
889 }
890 finally {
891 GroupThreadLocal.setDeleteInProcess(deleteInProcess);
892 }
893 }
894
895
909 @Override
910 public Group deleteGroup(long groupId) throws PortalException {
911 Group group = groupPersistence.findByPrimaryKey(groupId);
912
913 return deleteGroup(group);
914 }
915
916 @Override
917 public synchronized void disableStaging(long groupId)
918 throws PortalException {
919
920 Group group = groupPersistence.findByPrimaryKey(groupId);
921
922 int stagingGroupCount = group.getRemoteStagingGroupCount();
923
924 if (stagingGroupCount > 0) {
925 stagingGroupCount = stagingGroupCount - 1;
926
927 group.setRemoteStagingGroupCount(stagingGroupCount);
928
929 if (stagingGroupCount == 0) {
930 UnicodeProperties typeSettingsProperties =
931 group.getTypeSettingsProperties();
932
933 List<String> keys = new ArrayList<>();
934
935 for (String key : typeSettingsProperties.keySet()) {
936 if (key.startsWith(StagingConstants.STAGED_PORTLET)) {
937 keys.add(key);
938 }
939 }
940
941 for (String key : keys) {
942 typeSettingsProperties.remove(key);
943 }
944
945 group.setTypeSettingsProperties(typeSettingsProperties);
946 }
947
948 groupPersistence.update(group);
949 }
950 }
951
952 @Override
953 public synchronized void enableStaging(long groupId)
954 throws PortalException {
955
956 Group group = groupPersistence.findByPrimaryKey(groupId);
957
958 int stagingGroupCount = group.getRemoteStagingGroupCount() + 1;
959
960 group.setRemoteStagingGroupCount(stagingGroupCount);
961
962 groupPersistence.update(group);
963 }
964
965
972 @Override
973 public Group fetchCompanyGroup(long companyId) {
974 long classNameId = classNameLocalService.getClassNameId(Company.class);
975
976 return groupPersistence.fetchByC_C_C(companyId, classNameId, companyId);
977 }
978
979
987 @Override
988 public Group fetchFriendlyURLGroup(long companyId, String friendlyURL) {
989 if (Validator.isNull(friendlyURL)) {
990 return null;
991 }
992
993 friendlyURL = getFriendlyURL(friendlyURL);
994
995 return groupPersistence.fetchByC_F(companyId, friendlyURL);
996 }
997
998
1007 @Override
1008 @Skip
1009 public Group fetchGroup(long companyId, String groupKey) {
1010 Group group = _systemGroupsMap.get(
1011 StringUtil.toHexString(companyId).concat(groupKey));
1012
1013 if (group != null) {
1014 return group;
1015 }
1016
1017 return groupLocalService.loadFetchGroup(companyId, groupKey);
1018 }
1019
1020 @Override
1021 public Group fetchUserGroup(long companyId, long userId) {
1022 long classNameId = classNameLocalService.getClassNameId(User.class);
1023
1024 return groupPersistence.fetchByC_C_C(companyId, classNameId, userId);
1025 }
1026
1027
1035 @Override
1036 public Group fetchUserPersonalSiteGroup(long companyId)
1037 throws PortalException {
1038
1039 long classNameId = classNameLocalService.getClassNameId(
1040 UserPersonalSite.class);
1041 long defaultUserId = userLocalService.getDefaultUserId(companyId);
1042
1043 return groupPersistence.fetchByC_C_C(
1044 companyId, classNameId, defaultUserId);
1045 }
1046
1047
1055 @Override
1056 public List<Group> getActiveGroups(long companyId, boolean active) {
1057 return groupPersistence.findByC_A(companyId, active);
1058 }
1059
1060
1067 @Override
1068 public Group getCompanyGroup(long companyId) throws PortalException {
1069 long classNameId = classNameLocalService.getClassNameId(Company.class);
1070
1071 return groupPersistence.findByC_C_C(companyId, classNameId, companyId);
1072 }
1073
1074
1092 @Override
1093 public List<Group> getCompanyGroups(long companyId, int start, int end) {
1094 return groupPersistence.findByCompanyId(companyId, start, end);
1095 }
1096
1097
1103 @Override
1104 public int getCompanyGroupsCount(long companyId) {
1105 return groupPersistence.countByCompanyId(companyId);
1106 }
1107
1108
1116 @Override
1117 public Group getFriendlyURLGroup(long companyId, String friendlyURL)
1118 throws PortalException {
1119
1120 if (Validator.isNull(friendlyURL)) {
1121 StringBundler sb = new StringBundler(5);
1122
1123 sb.append("{companyId=");
1124 sb.append(companyId);
1125 sb.append(", friendlyURL=");
1126 sb.append(friendlyURL);
1127 sb.append("}");
1128
1129 throw new NoSuchGroupException(sb.toString());
1130 }
1131
1132 friendlyURL = getFriendlyURL(friendlyURL);
1133
1134 return groupPersistence.findByC_F(companyId, friendlyURL);
1135 }
1136
1137
1144 @Override
1145 @ThreadLocalCachable
1146 public Group getGroup(long groupId) throws PortalException {
1147 return groupPersistence.findByPrimaryKey(groupId);
1148 }
1149
1150
1158 @Override
1159 @Skip
1160 public Group getGroup(long companyId, String groupKey)
1161 throws PortalException {
1162
1163 Group group = _systemGroupsMap.get(
1164 StringUtil.toHexString(companyId).concat(groupKey));
1165
1166 if (group != null) {
1167 return group;
1168 }
1169
1170 return groupLocalService.loadGetGroup(companyId, groupKey);
1171 }
1172
1173
1177 @Deprecated
1178 @Override
1179 public String getGroupDescriptiveName(Group group, Locale locale)
1180 throws PortalException {
1181
1182 return group.getDescriptiveName(locale);
1183 }
1184
1185
1189 @Deprecated
1190 @Override
1191 public String getGroupDescriptiveName(long groupId, Locale locale)
1192 throws PortalException {
1193
1194 Group group = groupPersistence.findByPrimaryKey(groupId);
1195
1196 return group.getDescriptiveName(locale);
1197 }
1198
1199
1208 @Override
1209 public List<Group> getGroups(
1210 long companyId, long parentGroupId, boolean site) {
1211
1212 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
1213 return groupPersistence.findByC_S(companyId, site);
1214 }
1215
1216 return groupPersistence.findByC_P_S(companyId, parentGroupId, site);
1217 }
1218
1219 @Override
1220 public List<Group> getGroups(
1221 long companyId, long parentGroupId, boolean site,
1222 boolean inheritContent) {
1223
1224 return groupPersistence.findByC_P_S_I(
1225 companyId, parentGroupId, site, inheritContent);
1226 }
1227
1228
1238 @Override
1239 public List<Group> getGroups(
1240 long companyId, String className, long parentGroupId) {
1241
1242 long classNameId = classNameLocalService.getClassNameId(className);
1243
1244 return groupPersistence.findByC_C_P(
1245 companyId, classNameId, parentGroupId);
1246 }
1247
1248
1259 @Override
1260 public List<Group> getGroups(
1261 long companyId, String className, long parentGroupId, int start,
1262 int end) {
1263
1264 long classNameId = classNameLocalService.getClassNameId(className);
1265
1266 return groupPersistence.findByC_C_P(
1267 companyId, classNameId, parentGroupId, start, end);
1268 }
1269
1270
1277 @Override
1278 public List<Group> getGroups(long[] groupIds) throws PortalException {
1279 List<Group> groups = new ArrayList<>(groupIds.length);
1280
1281 for (long groupId : groupIds) {
1282 Group group = getGroup(groupId);
1283
1284 groups.add(group);
1285 }
1286
1287 return groups;
1288 }
1289
1290
1299 @Override
1300 public int getGroupsCount(
1301 long companyId, long parentGroupId, boolean site) {
1302
1303 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
1304 return groupPersistence.countByC_S(companyId, site);
1305 }
1306
1307 return groupPersistence.countByC_P_S(companyId, parentGroupId, site);
1308 }
1309
1310
1319 @Override
1320 public int getGroupsCount(
1321 long companyId, String className, long parentGroupId) {
1322
1323 long classNameId = classNameLocalService.getClassNameId(className);
1324
1325 return groupPersistence.countByC_C_P(
1326 companyId, classNameId, parentGroupId);
1327 }
1328
1329
1337 @Override
1338 public Group getLayoutGroup(long companyId, long plid)
1339 throws PortalException {
1340
1341 long classNameId = classNameLocalService.getClassNameId(Layout.class);
1342
1343 return groupPersistence.findByC_C_C(companyId, classNameId, plid);
1344 }
1345
1346
1354 @Override
1355 public Group getLayoutPrototypeGroup(long companyId, long layoutPrototypeId)
1356 throws PortalException {
1357
1358 long classNameId = classNameLocalService.getClassNameId(
1359 LayoutPrototype.class);
1360
1361 return groupPersistence.findByC_C_C(
1362 companyId, classNameId, layoutPrototypeId);
1363 }
1364
1365
1373 @Override
1374 public Group getLayoutSetPrototypeGroup(
1375 long companyId, long layoutSetPrototypeId)
1376 throws PortalException {
1377
1378 long classNameId = classNameLocalService.getClassNameId(
1379 LayoutSetPrototype.class);
1380
1381 return groupPersistence.findByC_C_C(
1382 companyId, classNameId, layoutSetPrototypeId);
1383 }
1384
1385
1409 @Override
1410 public List<Group> getLayoutsGroups(
1411 long companyId, long parentGroupId, boolean site, int start, int end,
1412 OrderByComparator<Group> obc) {
1413
1414 return groupFinder.findByLayouts(
1415 companyId, parentGroupId, site, start, end, obc);
1416 }
1417
1418
1427 @Override
1428 public int getLayoutsGroupsCount(
1429 long companyId, long parentGroupId, boolean site) {
1430
1431 return groupFinder.countByLayouts(companyId, parentGroupId, site);
1432 }
1433
1434
1439 @Override
1440 public List<Group> getLiveGroups() {
1441 return groupFinder.findByLiveGroups();
1442 }
1443
1444
1465 @Override
1466 public List<Group> getNoLayoutsGroups(
1467 String className, boolean privateLayout, int start, int end) {
1468
1469 long classNameId = classNameLocalService.getClassNameId(className);
1470
1471 return groupFinder.findByNoLayouts(
1472 classNameId, privateLayout, start, end);
1473 }
1474
1475
1482 @Override
1483 public List<Group> getNullFriendlyURLGroups() {
1484 return groupFinder.findByNullFriendlyURL();
1485 }
1486
1487
1495 @Override
1496 public Group getOrganizationGroup(long companyId, long organizationId)
1497 throws PortalException {
1498
1499 long classNameId = classNameLocalService.getClassNameId(
1500 Organization.class);
1501
1502 return groupPersistence.findByC_C_C(
1503 companyId, classNameId, organizationId);
1504 }
1505
1506
1512 @Override
1513 public List<Group> getOrganizationsGroups(
1514 List<Organization> organizations) {
1515
1516 List<Group> organizationGroups = new ArrayList<>();
1517
1518 for (int i = 0; i < organizations.size(); i++) {
1519 Organization organization = organizations.get(i);
1520
1521 Group group = organization.getGroup();
1522
1523 organizationGroups.add(group);
1524 }
1525
1526 return organizationGroups;
1527 }
1528
1529
1535 @Override
1536 public List<Group> getOrganizationsRelatedGroups(
1537 List<Organization> organizations) {
1538
1539 List<Group> organizationGroups = new ArrayList<>();
1540
1541 for (int i = 0; i < organizations.size(); i++) {
1542 Organization organization = organizations.get(i);
1543
1544 List<Group> groups = organizationPersistence.getGroups(
1545 organization.getOrganizationId());
1546
1547 organizationGroups.addAll(groups);
1548 }
1549
1550 return organizationGroups;
1551 }
1552
1553
1562 @Override
1563 public List<Group> getParentGroups(long groupId) throws PortalException {
1564 if (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
1565 return new ArrayList<>();
1566 }
1567
1568 Group group = groupPersistence.findByPrimaryKey(groupId);
1569
1570 return group.getAncestors();
1571 }
1572
1573
1580 @Override
1581 public Group getStagingGroup(long liveGroupId) throws PortalException {
1582 return groupPersistence.findByLiveGroupId(liveGroupId);
1583 }
1584
1585
1593 @Override
1594 public Group getUserGroup(long companyId, long userId)
1595 throws PortalException {
1596
1597 long classNameId = classNameLocalService.getClassNameId(User.class);
1598
1599 return groupPersistence.findByC_C_C(companyId, classNameId, userId);
1600 }
1601
1602
1611 @Override
1612 public Group getUserGroupGroup(long companyId, long userGroupId)
1613 throws PortalException {
1614
1615 long classNameId = classNameLocalService.getClassNameId(
1616 UserGroup.class);
1617
1618 return groupPersistence.findByC_C_C(
1619 companyId, classNameId, userGroupId);
1620 }
1621
1622
1633 @Override
1634 public List<Group> getUserGroups(long userId, boolean inherit)
1635 throws PortalException {
1636
1637 return getUserGroups(
1638 userId, inherit, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1639 }
1640
1641
1666 @Override
1667 public List<Group> getUserGroups(
1668 long userId, boolean inherit, int start, int end)
1669 throws PortalException {
1670
1671 if (inherit) {
1672 User user = userPersistence.findByPrimaryKey(userId);
1673
1674 LinkedHashMap<String, Object> groupParams = new LinkedHashMap<>();
1675
1676 groupParams.put("usersGroups", Long.valueOf(userId));
1677
1678 return search(
1679 user.getCompanyId(), null, null, groupParams, start, end);
1680 }
1681 else {
1682 return userPersistence.getGroups(userId, start, end);
1683 }
1684 }
1685
1686
1693 @Override
1694 public List<Group> getUserGroupsGroups(List<UserGroup> userGroups)
1695 throws PortalException {
1696
1697 List<Group> userGroupGroups = new ArrayList<>();
1698
1699 for (int i = 0; i < userGroups.size(); i++) {
1700 UserGroup userGroup = userGroups.get(i);
1701
1702 Group group = userGroup.getGroup();
1703
1704 userGroupGroups.add(group);
1705 }
1706
1707 return userGroupGroups;
1708 }
1709
1710
1716 @Override
1717 public List<Group> getUserGroupsRelatedGroups(List<UserGroup> userGroups) {
1718 List<Group> userGroupGroups = new ArrayList<>();
1719
1720 for (int i = 0; i < userGroups.size(); i++) {
1721 UserGroup userGroup = userGroups.get(i);
1722
1723 List<Group> groups = userGroupPersistence.getGroups(
1724 userGroup.getUserGroupId());
1725
1726 userGroupGroups.addAll(groups);
1727 }
1728
1729 return userGroupGroups;
1730 }
1731
1732
1755 @Override
1756 public List<Group> getUserOrganizationsGroups(
1757 long userId, int start, int end)
1758 throws PortalException {
1759
1760 List<Group> userOrgsGroups = new ArrayList<>();
1761
1762 List<Organization> userOrgs =
1763 organizationLocalService.getUserOrganizations(userId, start, end);
1764
1765 for (Organization organization : userOrgs) {
1766 userOrgsGroups.add(0, organization.getGroup());
1767
1768 if (!PropsValues.ORGANIZATIONS_MEMBERSHIP_STRICT) {
1769 for (Organization ancestorOrganization :
1770 organization.getAncestors()) {
1771
1772 userOrgsGroups.add(0, ancestorOrganization.getGroup());
1773 }
1774 }
1775 }
1776
1777 return ListUtil.unique(userOrgsGroups);
1778 }
1779
1780
1787 @Override
1788 public Group getUserPersonalSiteGroup(long companyId)
1789 throws PortalException {
1790
1791 long classNameId = classNameLocalService.getClassNameId(
1792 UserPersonalSite.class);
1793 long defaultUserId = userLocalService.getDefaultUserId(companyId);
1794
1795 return groupPersistence.findByC_C_C(
1796 companyId, classNameId, defaultUserId);
1797 }
1798
1799 @Override
1800 public List<Group> getUserSitesGroups(long userId) throws PortalException {
1801 User user = userPersistence.findByPrimaryKey(userId);
1802
1803 LinkedHashMap<String, Object> groupParams = new LinkedHashMap<>();
1804
1805 groupParams.put("inherit", Boolean.TRUE);
1806 groupParams.put("site", Boolean.TRUE);
1807 groupParams.put("usersGroups", userId);
1808
1809 return groupFinder.findByCompanyId(
1810 user.getCompanyId(), groupParams, QueryUtil.ALL_POS,
1811 QueryUtil.ALL_POS, new GroupNameComparator(true));
1812 }
1813
1814 @Override
1815 public List<Group> getUserSitesGroups(
1816 long userId, boolean includeAdministrative)
1817 throws PortalException {
1818
1819 if (!includeAdministrative) {
1820 return getUserSitesGroups(userId);
1821 }
1822
1823 Set<Group> sites = new HashSet<>();
1824
1825 List<UserGroupRole> userGroupRoles =
1826 userGroupRoleLocalService.getUserGroupRoles(userId);
1827
1828 for (UserGroupRole userGroupRole : userGroupRoles) {
1829 Role role = userGroupRole.getRole();
1830
1831 String roleName = role.getName();
1832
1833 if (roleName.equals(RoleConstants.SITE_ADMINISTRATOR) ||
1834 roleName.equals(RoleConstants.SITE_OWNER)) {
1835
1836 Group group = userGroupRole.getGroup();
1837
1838 sites.add(group);
1839 }
1840 }
1841
1842 sites.addAll(getUserSitesGroups(userId));
1843
1844 return new ArrayList<>(sites);
1845 }
1846
1847
1854 @Override
1855 public boolean hasStagingGroup(long liveGroupId) {
1856 if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
1857 return true;
1858 }
1859 else {
1860 return false;
1861 }
1862 }
1863
1864
1874 @Override
1875 public boolean hasUserGroup(long userId, long groupId) {
1876 return hasUserGroup(userId, groupId, true);
1877 }
1878
1879
1891 @Override
1892 public boolean hasUserGroup(long userId, long groupId, boolean inherit) {
1893 if (groupFinder.countByG_U(groupId, userId, inherit) > 0) {
1894 return true;
1895 }
1896 else {
1897 return false;
1898 }
1899 }
1900
1901
1910 @Override
1911 public Group loadFetchGroup(long companyId, String groupKey) {
1912 return groupPersistence.fetchByC_GK(companyId, groupKey);
1913 }
1914
1915
1923 @Override
1924 public Group loadGetGroup(long companyId, String groupKey)
1925 throws PortalException {
1926
1927 return groupPersistence.findByC_GK(companyId, groupKey);
1928 }
1929
1930
1942 @Override
1943 public void rebuildTree(long companyId) throws PortalException {
1944 TreePathUtil.rebuildTree(
1945 companyId, GroupConstants.DEFAULT_PARENT_GROUP_ID, StringPool.SLASH,
1946 new TreeModelTasksAdapter<Group>() {
1947
1948 @Override
1949 public List<Group> findTreeModels(
1950 long previousId, long companyId, long parentPrimaryKey,
1951 int size) {
1952
1953 return groupPersistence.findByG_C_P(
1954 previousId, companyId, parentPrimaryKey,
1955 QueryUtil.ALL_POS, size, new GroupIdComparator(true));
1956 }
1957
1958 }
1959 );
1960 }
1961
1962
1989 @Override
1990 public List<Group> search(
1991 long companyId, LinkedHashMap<String, Object> params, int start,
1992 int end) {
1993
1994 return groupFinder.findByCompanyId(
1995 companyId, params, start, end, new GroupNameComparator(true));
1996 }
1997
1998
2028 @Override
2029 public List<Group> search(
2030 long companyId, long parentGroupId, String keywords,
2031 LinkedHashMap<String, Object> params, int start, int end) {
2032
2033 return search(
2034 companyId, getClassNameIds(), parentGroupId, keywords, params,
2035 start, end, null);
2036 }
2037
2038
2070 @Override
2071 public List<Group> search(
2072 long companyId, long parentGroupId, String keywords,
2073 LinkedHashMap<String, Object> params, int start, int end,
2074 OrderByComparator<Group> obc) {
2075
2076 return search(
2077 companyId, getClassNameIds(), parentGroupId, keywords, params,
2078 start, end, obc);
2079 }
2080
2081
2114 @Override
2115 public List<Group> search(
2116 long companyId, long parentGroupId, String name, String description,
2117 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2118 int end) {
2119
2120 return search(
2121 companyId, getClassNameIds(), parentGroupId, name, description,
2122 params, andOperator, start, end, null);
2123 }
2124
2125
2160 @Override
2161 public List<Group> search(
2162 long companyId, long parentGroupId, String name, String description,
2163 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2164 int end, OrderByComparator<Group> obc) {
2165
2166 return search(
2167 companyId, getClassNameIds(), parentGroupId, name, description,
2168 params, andOperator, start, end, obc);
2169 }
2170
2171
2204 @Override
2205 public List<Group> search(
2206 long companyId, long[] classNameIds, long parentGroupId,
2207 String keywords, LinkedHashMap<String, Object> params, int start,
2208 int end) {
2209
2210 return search(
2211 companyId, classNameIds, parentGroupId, keywords, params, start,
2212 end, null);
2213 }
2214
2215
2250 @Override
2251 public List<Group> search(
2252 long companyId, long[] classNameIds, long parentGroupId,
2253 String keywords, LinkedHashMap<String, Object> params, int start,
2254 int end, OrderByComparator<Group> obc) {
2255
2256 String[] keywordsArray = getSearchNames(companyId, keywords);
2257
2258 boolean andOperator = false;
2259
2260 if (Validator.isNull(keywords)) {
2261 andOperator = true;
2262 }
2263
2264 if (isUseComplexSQL(classNameIds)) {
2265 return groupFinder.findByC_C_PG_N_D(
2266 companyId, classNameIds, parentGroupId, keywordsArray,
2267 keywordsArray, params, andOperator, start, end, obc);
2268 }
2269
2270 Collection<Group> groups = doSearch(
2271 companyId, classNameIds, parentGroupId, keywordsArray,
2272 keywordsArray, params, andOperator);
2273
2274 return sort(groups, start, end, obc);
2275 }
2276
2277
2313 @Override
2314 public List<Group> search(
2315 long companyId, long[] classNameIds, long parentGroupId, String name,
2316 String description, LinkedHashMap<String, Object> params,
2317 boolean andOperator, int start, int end) {
2318
2319 return search(
2320 companyId, classNameIds, parentGroupId, name, description, params,
2321 andOperator, start, end, null);
2322 }
2323
2324
2362 @Override
2363 public List<Group> search(
2364 long companyId, long[] classNameIds, long parentGroupId, String name,
2365 String description, LinkedHashMap<String, Object> params,
2366 boolean andOperator, int start, int end, OrderByComparator<Group> obc) {
2367
2368 String[] names = getSearchNames(companyId, name);
2369 String[] descriptions = CustomSQLUtil.keywords(description);
2370
2371 if (isUseComplexSQL(classNameIds)) {
2372 return groupFinder.findByC_C_PG_N_D(
2373 companyId, classNameIds, parentGroupId, names, descriptions,
2374 params, andOperator, start, end, obc);
2375 }
2376
2377 Collection<Group> groups = doSearch(
2378 companyId, classNameIds, parentGroupId, names, descriptions, params,
2379 andOperator);
2380
2381 return sort(groups, start, end, obc);
2382 }
2383
2384
2415 @Override
2416 public List<Group> search(
2417 long companyId, long[] classNameIds, String keywords,
2418 LinkedHashMap<String, Object> params, int start, int end) {
2419
2420 return search(
2421 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
2422 keywords, params, start, end, null);
2423 }
2424
2425
2458 @Override
2459 public List<Group> search(
2460 long companyId, long[] classNameIds, String keywords,
2461 LinkedHashMap<String, Object> params, int start, int end,
2462 OrderByComparator<Group> obc) {
2463
2464 return search(
2465 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
2466 keywords, params, start, end, obc);
2467 }
2468
2469
2504 @Override
2505 public List<Group> search(
2506 long companyId, long[] classNameIds, String name, String description,
2507 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2508 int end) {
2509
2510 return search(
2511 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
2512 description, params, andOperator, start, end, null);
2513 }
2514
2515
2552 @Override
2553 public List<Group> search(
2554 long companyId, long[] classNameIds, String name, String description,
2555 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2556 int end, OrderByComparator<Group> obc) {
2557
2558 return search(
2559 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
2560 description, params, andOperator, start, end, obc);
2561 }
2562
2563
2591 @Override
2592 @ThreadLocalCachable
2593 public List<Group> search(
2594 long companyId, String keywords, LinkedHashMap<String, Object> params,
2595 int start, int end) {
2596
2597 return search(
2598 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2599 keywords, params, start, end, null);
2600 }
2601
2602
2632 @Override
2633 public List<Group> search(
2634 long companyId, String keywords, LinkedHashMap<String, Object> params,
2635 int start, int end, OrderByComparator<Group> obc) {
2636
2637 return search(
2638 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2639 keywords, params, start, end, obc);
2640 }
2641
2642
2674 @Override
2675 public List<Group> search(
2676 long companyId, String name, String description,
2677 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2678 int end) {
2679
2680 return search(
2681 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2682 name, description, params, andOperator, start, end, null);
2683 }
2684
2685
2719 @Override
2720 public List<Group> search(
2721 long companyId, String name, String description,
2722 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2723 int end, OrderByComparator<Group> obc) {
2724
2725 return search(
2726 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2727 name, description, params, andOperator, start, end, obc);
2728 }
2729
2730
2747 @Override
2748 @ThreadLocalCachable
2749 public int searchCount(
2750 long companyId, long parentGroupId, String keywords,
2751 LinkedHashMap<String, Object> params) {
2752
2753 return searchCount(
2754 companyId, getClassNameIds(), parentGroupId, keywords, params);
2755 }
2756
2757
2778 @Override
2779 @ThreadLocalCachable
2780 public int searchCount(
2781 long companyId, long parentGroupId, String name, String description,
2782 LinkedHashMap<String, Object> params, boolean andOperator) {
2783
2784 return searchCount(
2785 companyId, getClassNameIds(), parentGroupId, name, description,
2786 params, andOperator);
2787 }
2788
2789
2809 @Override
2810 @ThreadLocalCachable
2811 public int searchCount(
2812 long companyId, long[] classNameIds, long parentGroupId,
2813 String keywords, LinkedHashMap<String, Object> params) {
2814
2815 String[] keywordsArray = getSearchNames(companyId, keywords);
2816
2817 boolean andOperator = false;
2818
2819 if (Validator.isNull(keywords)) {
2820 andOperator = true;
2821 }
2822
2823 if (isUseComplexSQL(classNameIds)) {
2824 return groupFinder.countByC_C_PG_N_D(
2825 companyId, classNameIds, parentGroupId, keywordsArray,
2826 keywordsArray, params, andOperator);
2827 }
2828
2829 Collection<Group> groups = doSearch(
2830 companyId, classNameIds, parentGroupId, keywordsArray,
2831 keywordsArray, params, andOperator);
2832
2833 return groups.size();
2834 }
2835
2836
2859 @Override
2860 @ThreadLocalCachable
2861 public int searchCount(
2862 long companyId, long[] classNameIds, long parentGroupId, String name,
2863 String description, LinkedHashMap<String, Object> params,
2864 boolean andOperator) {
2865
2866 String[] names = getSearchNames(companyId, name);
2867 String[] descriptions = CustomSQLUtil.keywords(description);
2868
2869 if (isUseComplexSQL(classNameIds)) {
2870 return groupFinder.countByC_C_PG_N_D(
2871 companyId, classNameIds, parentGroupId, names, descriptions,
2872 params, andOperator);
2873 }
2874
2875 Collection<Group> groups = doSearch(
2876 companyId, classNameIds, parentGroupId, names, descriptions, params,
2877 andOperator);
2878
2879 return groups.size();
2880 }
2881
2882
2900 @Override
2901 @ThreadLocalCachable
2902 public int searchCount(
2903 long companyId, long[] classNameIds, String keywords,
2904 LinkedHashMap<String, Object> params) {
2905
2906 return searchCount(
2907 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
2908 keywords, params);
2909 }
2910
2911
2932 @Override
2933 @ThreadLocalCachable
2934 public int searchCount(
2935 long companyId, long[] classNameIds, String name, String description,
2936 LinkedHashMap<String, Object> params, boolean andOperator) {
2937
2938 return searchCount(
2939 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
2940 description, params, andOperator);
2941 }
2942
2943
2959 @Override
2960 @ThreadLocalCachable
2961 public int searchCount(
2962 long companyId, String keywords, LinkedHashMap<String, Object> params) {
2963
2964 return searchCount(
2965 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2966 keywords, params);
2967 }
2968
2969
2989 @Override
2990 @ThreadLocalCachable
2991 public int searchCount(
2992 long companyId, String name, String description,
2993 LinkedHashMap<String, Object> params, boolean andOperator) {
2994
2995 return searchCount(
2996 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2997 name, description, params, andOperator);
2998 }
2999
3000
3007 @Override
3008 public void setRoleGroups(long roleId, long[] groupIds) {
3009 rolePersistence.setGroups(roleId, groupIds);
3010
3011 PermissionCacheUtil.clearCache();
3012 }
3013
3014
3020 @Override
3021 public void unsetRoleGroups(long roleId, long[] groupIds) {
3022 rolePersistence.removeGroups(roleId, groupIds);
3023
3024 PermissionCacheUtil.clearCache();
3025 }
3026
3027
3033 @Override
3034 public void unsetUserGroups(long userId, long[] groupIds) {
3035 userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
3036
3037 userPersistence.removeGroups(userId, groupIds);
3038
3039 PermissionCacheUtil.clearCache(userId);
3040 }
3041
3042
3052 @Override
3053 public void updateAsset(
3054 long userId, Group group, long[] assetCategoryIds,
3055 String[] assetTagNames)
3056 throws PortalException {
3057
3058 User user = userPersistence.findByPrimaryKey(userId);
3059
3060 Company company = companyPersistence.findByPrimaryKey(
3061 user.getCompanyId());
3062
3063 Group companyGroup = company.getGroup();
3064
3065 assetEntryLocalService.updateEntry(
3066 userId, companyGroup.getGroupId(), null, null,
3067 Group.class.getName(), group.getGroupId(), null, 0,
3068 assetCategoryIds, assetTagNames, false, null, null, null, null,
3069 group.getDescriptiveName(), group.getDescription(), null, null,
3070 null, 0, 0, null);
3071 }
3072
3073
3082 @Override
3083 public Group updateFriendlyURL(long groupId, String friendlyURL)
3084 throws PortalException {
3085
3086 Group group = groupPersistence.findByPrimaryKey(groupId);
3087
3088 if (group.isUser()) {
3089 User user = userPersistence.findByPrimaryKey(group.getClassPK());
3090
3091 friendlyURL = StringPool.SLASH + user.getScreenName();
3092
3093 if (group.getFriendlyURL().equals(friendlyURL)) {
3094 return group;
3095 }
3096 }
3097
3098 friendlyURL = getFriendlyURL(
3099 group.getCompanyId(), groupId, group.getClassNameId(),
3100 group.getClassPK(), StringPool.BLANK, friendlyURL);
3101
3102 validateFriendlyURL(
3103 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
3104 group.getClassPK(), friendlyURL);
3105
3106 group.setFriendlyURL(friendlyURL);
3107
3108 groupPersistence.update(group);
3109
3110 return group;
3111 }
3112
3113 @Override
3114 public Group updateGroup(
3115 long groupId, long parentGroupId, Map<Locale, String> nameMap,
3116 Map<Locale, String> descriptionMap, int type,
3117 boolean manualMembership, int membershipRestriction,
3118 String friendlyURL, boolean inheritContent, boolean active,
3119 ServiceContext serviceContext)
3120 throws PortalException {
3121
3122 Group group = groupPersistence.findByPrimaryKey(groupId);
3123
3124 String className = group.getClassName();
3125 long classNameId = group.getClassNameId();
3126 long classPK = group.getClassPK();
3127
3128 String groupKey = group.getGroupKey();
3129
3130 if ((nameMap != null) &&
3131 Validator.isNotNull(nameMap.get(LocaleUtil.getDefault()))) {
3132
3133 groupKey = nameMap.get(LocaleUtil.getDefault());
3134 }
3135
3136 friendlyURL = getFriendlyURL(
3137 group.getCompanyId(), groupId, classNameId, classPK,
3138 StringPool.BLANK, friendlyURL);
3139
3140 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
3141 validateGroupKey(
3142 group.getGroupId(), group.getCompanyId(), groupKey,
3143 group.isSite());
3144 }
3145 else if (className.equals(Organization.class.getName())) {
3146 Organization organization =
3147 organizationPersistence.findByPrimaryKey(classPK);
3148
3149 groupKey = getOrgGroupName(organization.getName());
3150 }
3151 else if (!GroupConstants.USER_PERSONAL_SITE.equals(
3152 group.getGroupKey())) {
3153
3154 groupKey = String.valueOf(classPK);
3155 }
3156
3157 if (PortalUtil.isSystemGroup(group.getGroupKey()) &&
3158 !groupKey.equals(group.getGroupKey())) {
3159
3160 throw new RequiredGroupException.MustNotDeleteSystemGroup(
3161 group.getGroupId());
3162 }
3163
3164 validateFriendlyURL(
3165 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
3166 group.getClassPK(), friendlyURL);
3167
3168 validateParentGroup(group.getGroupId(), parentGroupId);
3169
3170 group.setParentGroupId(parentGroupId);
3171 group.setTreePath(group.buildTreePath());
3172 group.setGroupKey(groupKey);
3173 group.setNameMap(nameMap);
3174 group.setDescriptionMap(descriptionMap);
3175 group.setType(type);
3176 group.setManualMembership(manualMembership);
3177 group.setMembershipRestriction(membershipRestriction);
3178 group.setFriendlyURL(friendlyURL);
3179 group.setInheritContent(inheritContent);
3180 group.setActive(active);
3181
3182 if ((serviceContext != null) && group.isSite()) {
3183 group.setExpandoBridgeAttributes(serviceContext);
3184 }
3185
3186 groupPersistence.update(group);
3187
3188
3189
3190 if ((serviceContext == null) || !group.isSite()) {
3191 return group;
3192 }
3193
3194 User user = null;
3195
3196 user = userPersistence.fetchByPrimaryKey(group.getCreatorUserId());
3197
3198 if (user == null) {
3199 user = userPersistence.fetchByPrimaryKey(
3200 serviceContext.getUserId());
3201 }
3202
3203 if (user == null) {
3204 user = userLocalService.getDefaultUser(group.getCompanyId());
3205 }
3206
3207 updateAsset(
3208 user.getUserId(), group, serviceContext.getAssetCategoryIds(),
3209 serviceContext.getAssetTagNames());
3210
3211 return group;
3212 }
3213
3214
3242 @Deprecated
3243 @Override
3244 public Group updateGroup(
3245 long groupId, long parentGroupId, String name, String description,
3246 int type, boolean manualMembership, int membershipRestriction,
3247 String friendlyURL, boolean inheritContent, boolean active,
3248 ServiceContext serviceContext)
3249 throws PortalException {
3250
3251 return updateGroup(
3252 groupId, parentGroupId, getLocalizationMap(name),
3253 getLocalizationMap(description), type, manualMembership,
3254 membershipRestriction, friendlyURL, inheritContent, active,
3255 serviceContext);
3256 }
3257
3258
3267 @Override
3268 public Group updateGroup(long groupId, String typeSettings)
3269 throws PortalException {
3270
3271 Group group = groupPersistence.findByPrimaryKey(groupId);
3272
3273 UnicodeProperties oldTypeSettingsProperties =
3274 group.getTypeSettingsProperties();
3275
3276 UnicodeProperties typeSettingsProperties = new UnicodeProperties(true);
3277
3278 typeSettingsProperties.fastLoad(typeSettings);
3279
3280 String newLanguageIds = typeSettingsProperties.getProperty(
3281 PropsKeys.LOCALES);
3282
3283 if (Validator.isNotNull(newLanguageIds)) {
3284 String oldLanguageIds = oldTypeSettingsProperties.getProperty(
3285 PropsKeys.LOCALES, StringPool.BLANK);
3286
3287 String defaultLanguageId = typeSettingsProperties.getProperty(
3288 "languageId", LocaleUtil.toLanguageId(LocaleUtil.getDefault()));
3289
3290 validateLanguageIds(defaultLanguageId, newLanguageIds);
3291
3292 if (!Validator.equals(oldLanguageIds, newLanguageIds)) {
3293 LanguageUtil.resetAvailableGroupLocales(groupId);
3294 }
3295 }
3296
3297 group.setTypeSettings(typeSettings);
3298
3299 groupPersistence.update(group);
3300
3301 return group;
3302 }
3303
3304
3312 @Override
3313 public Group updateSite(long groupId, boolean site) throws PortalException {
3314 Group group = groupPersistence.findByPrimaryKey(groupId);
3315
3316 if (!group.isOrganization()) {
3317 return group;
3318 }
3319
3320 group.setSite(site);
3321
3322 groupPersistence.update(group);
3323
3324 return group;
3325 }
3326
3327 protected void addControlPanelLayouts(Group group) throws PortalException {
3328 long defaultUserId = userLocalService.getDefaultUserId(
3329 group.getCompanyId());
3330
3331 String friendlyURL = getFriendlyURL(
3332 PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
3333
3334 ServiceContext serviceContext = new ServiceContext();
3335
3336 serviceContext.setAttribute(
3337 "layout.instanceable.allowed", Boolean.TRUE);
3338
3339 layoutLocalService.addLayout(
3340 defaultUserId, group.getGroupId(), true,
3341 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
3342 PropsValues.CONTROL_PANEL_LAYOUT_NAME, StringPool.BLANK,
3343 StringPool.BLANK, LayoutConstants.TYPE_CONTROL_PANEL, false,
3344 friendlyURL, serviceContext);
3345 }
3346
3347 protected void addDefaultGuestPublicLayoutByProperties(Group group)
3348 throws PortalException {
3349
3350 List<Portlet> portlets = portletLocalService.getPortlets(
3351 group.getCompanyId());
3352
3353 if (portlets.isEmpty()) {
3354
3355
3356
3357 return;
3358 }
3359
3360 long defaultUserId = userLocalService.getDefaultUserId(
3361 group.getCompanyId());
3362 String friendlyURL = getFriendlyURL(
3363 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
3364
3365 ServiceContext serviceContext = new ServiceContext();
3366
3367 Layout layout = layoutLocalService.addLayout(
3368 defaultUserId, group.getGroupId(), false,
3369 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
3370 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
3371 StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL,
3372 serviceContext);
3373
3374 LayoutTypePortlet layoutTypePortlet =
3375 (LayoutTypePortlet)layout.getLayoutType();
3376
3377 layoutTypePortlet.setLayoutTemplateId(
3378 0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
3379
3380 LayoutTemplate layoutTemplate = layoutTypePortlet.getLayoutTemplate();
3381
3382 for (String columnId : layoutTemplate.getColumns()) {
3383 String keyPrefix = PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_PREFIX;
3384
3385 String portletIds = PropsUtil.get(keyPrefix.concat(columnId));
3386
3387 layoutTypePortlet.addPortletIds(
3388 0, StringUtil.split(portletIds), columnId, false);
3389 }
3390
3391 layoutLocalService.updateLayout(
3392 layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
3393 layout.getTypeSettings());
3394
3395 boolean updateLayoutSet = false;
3396
3397 LayoutSet layoutSet = layout.getLayoutSet();
3398
3399 if (Validator.isNotNull(
3400 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
3401
3402 layoutSet.setThemeId(
3403 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
3404
3405 updateLayoutSet = true;
3406 }
3407
3408 if (Validator.isNotNull(
3409 PropsValues.
3410 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
3411
3412 layoutSet.setColorSchemeId(
3413 PropsValues.
3414 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
3415
3416 updateLayoutSet = true;
3417 }
3418
3419 if (Validator.isNotNull(
3420 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
3421
3422 layoutSet.setWapThemeId(
3423 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
3424
3425 updateLayoutSet = true;
3426 }
3427
3428 if (Validator.isNotNull(
3429 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
3430
3431 layoutSet.setWapColorSchemeId(
3432 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
3433
3434 updateLayoutSet = true;
3435 }
3436
3437 if (updateLayoutSet) {
3438 layoutSetLocalService.updateLayoutSet(layoutSet);
3439 }
3440 }
3441
3442 protected void addDefaultGuestPublicLayouts(Group group)
3443 throws PortalException {
3444
3445 if (publicLARFile != null) {
3446 addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
3447 }
3448 else {
3449 addDefaultGuestPublicLayoutByProperties(group);
3450 }
3451 }
3452
3453 protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
3454 throws PortalException {
3455
3456 User defaultUser = userLocalService.getDefaultUser(
3457 group.getCompanyId());
3458
3459 Map<String, String[]> parameterMap = new HashMap<>();
3460
3461 parameterMap.put(
3462 PortletDataHandlerKeys.PERMISSIONS,
3463 new String[] {Boolean.TRUE.toString()});
3464 parameterMap.put(
3465 PortletDataHandlerKeys.PORTLET_CONFIGURATION,
3466 new String[] {Boolean.TRUE.toString()});
3467 parameterMap.put(
3468 PortletDataHandlerKeys.PORTLET_DATA,
3469 new String[] {Boolean.TRUE.toString()});
3470 parameterMap.put(
3471 PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
3472 new String[] {Boolean.TRUE.toString()});
3473
3474 Map<String, Serializable> importLayoutSettingsMap =
3475 ExportImportConfigurationSettingsMapFactory.
3476 buildImportLayoutSettingsMap(
3477 defaultUser, group.getGroupId(), false, null, parameterMap);
3478
3479 ExportImportConfiguration exportImportConfiguration =
3480 exportImportConfigurationLocalService.
3481 addDraftExportImportConfiguration(
3482 defaultUser.getUserId(),
3483 ExportImportConfigurationConstants.TYPE_IMPORT_LAYOUT,
3484 importLayoutSettingsMap);
3485
3486 exportImportLocalService.importLayouts(
3487 exportImportConfiguration, larFile);
3488 }
3489
3490 protected void addPortletDefaultData(Group group) throws PortalException {
3491 PortletDataContext portletDataContext =
3492 PortletDataContextFactoryUtil.createPreparePortletDataContext(
3493 group.getCompanyId(), group.getGroupId(), null, null);
3494
3495 List<PortletDataHandler> portletDataHandlers = getPortletDataHandlers(
3496 group);
3497
3498 for (PortletDataHandler portletDataHandler : portletDataHandlers) {
3499 try {
3500 portletDataHandler.addDefaultData(
3501 portletDataContext, portletDataHandler.getPortletId(),
3502 null);
3503 }
3504 catch (Exception e) {
3505 _log.error(
3506 "Unable to add default data for portlet " +
3507 portletDataHandler.getPortletId() + " in group " +
3508 group.getGroupId());
3509
3510 if (portletDataHandler.isRollbackOnException()) {
3511 throw new SystemException(e);
3512 }
3513 }
3514 }
3515 }
3516
3517 protected void deletePortletData(Group group) throws PortalException {
3518 PortletDataContext portletDataContext =
3519 PortletDataContextFactoryUtil.createPreparePortletDataContext(
3520 group.getCompanyId(), group.getGroupId(), null, null);
3521
3522 List<PortletDataHandler> portletDataHandlers = getPortletDataHandlers(
3523 group);
3524
3525 for (PortletDataHandler portletDataHandler : portletDataHandlers) {
3526 try {
3527 portletDataHandler.deleteData(
3528 portletDataContext, portletDataHandler.getPortletId(),
3529 null);
3530 }
3531 catch (Exception e) {
3532 _log.error(
3533 "Unable to delete data for portlet " +
3534 portletDataHandler.getPortletId() + " in group " +
3535 group.getGroupId());
3536
3537 if (portletDataHandler.isRollbackOnException()) {
3538 throw new SystemException(e);
3539 }
3540 }
3541 }
3542 }
3543
3544 protected Collection<Group> doSearch(
3545 long companyId, long[] classNameIds, long parentGroupId, String[] names,
3546 String[] descriptions, LinkedHashMap<String, Object> params,
3547 boolean andOperator) {
3548
3549 boolean parentGroupIdEquals = true;
3550
3551 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
3552 parentGroupIdEquals = false;
3553 }
3554
3555 params = new LinkedHashMap<>(params);
3556
3557 Boolean active = (Boolean)params.remove("active");
3558 List<Long> excludedGroupIds = (List<Long>)params.remove(
3559 "excludedGroupIds");
3560 List<Group> groupsTree = (List<Group>)params.remove("groupsTree");
3561 Boolean manualMembership = (Boolean)params.remove("manualMembership");
3562 Integer membershipRestriction = (Integer)params.remove(
3563 "membershipRestriction");
3564 Boolean site = (Boolean)params.remove("site");
3565 List<Integer> types = (List<Integer>)params.remove("types");
3566
3567 Collection<Group> groups = new HashSet<>();
3568
3569 Long userId = (Long)params.remove("usersGroups");
3570
3571 for (long classNameId : classNameIds) {
3572 groups.addAll(groupPersistence.findByC_C(companyId, classNameId));
3573 }
3574
3575 Iterator<Group> iterator = groups.iterator();
3576
3577 while (iterator.hasNext()) {
3578 Group group = iterator.next();
3579
3580
3581
3582 long liveGroupId = group.getLiveGroupId();
3583
3584 if (liveGroupId != 0) {
3585 iterator.remove();
3586
3587 continue;
3588 }
3589
3590
3591
3592 long groupParentGroupId = group.getParentGroupId();
3593
3594 if ((parentGroupIdEquals &&
3595 (groupParentGroupId != parentGroupId)) ||
3596 (!parentGroupIdEquals &&
3597 (groupParentGroupId == parentGroupId))) {
3598
3599 iterator.remove();
3600
3601 continue;
3602 }
3603
3604
3605
3606 String groupKey = group.getGroupKey();
3607
3608 if (groupKey.equals(GroupConstants.CONTROL_PANEL)) {
3609 iterator.remove();
3610
3611 continue;
3612 }
3613
3614 boolean containsName = matches(group.getNameCurrentValue(), names);
3615 boolean containsDescription = matches(
3616 group.getDescriptionCurrentValue(), descriptions);
3617
3618 if ((andOperator && (!containsName || !containsDescription)) ||
3619 (!andOperator && !containsName && !containsDescription)) {
3620
3621 iterator.remove();
3622
3623 continue;
3624 }
3625
3626
3627
3628 if (active != null) {
3629 if (active != group.isActive()) {
3630 iterator.remove();
3631
3632 continue;
3633 }
3634 }
3635
3636
3637
3638 if ((excludedGroupIds != null) &&
3639 excludedGroupIds.contains(group.getGroupId())) {
3640
3641 iterator.remove();
3642
3643 continue;
3644 }
3645
3646
3647
3648 if (groupsTree != null) {
3649 String treePath = group.getTreePath();
3650
3651 boolean matched = false;
3652
3653 for (Group groupTree : groupsTree) {
3654 String groupTreePath = StringUtil.quote(
3655 String.valueOf(groupTree.getGroupId()),
3656 StringPool.SLASH);
3657
3658 if (treePath.contains(groupTreePath)) {
3659 matched = true;
3660
3661 break;
3662 }
3663 }
3664
3665 if (!matched) {
3666 iterator.remove();
3667
3668 continue;
3669 }
3670 }
3671
3672
3673
3674 if ((manualMembership != null) &&
3675 (manualMembership != group.isManualMembership())) {
3676
3677 iterator.remove();
3678
3679 continue;
3680 }
3681
3682
3683
3684 if ((membershipRestriction != null) &&
3685 (membershipRestriction != group.getMembershipRestriction())) {
3686
3687 iterator.remove();
3688
3689 continue;
3690 }
3691
3692
3693
3694 if (site != null) {
3695 if (site != group.isSite()) {
3696 iterator.remove();
3697
3698 continue;
3699 }
3700 }
3701
3702
3703
3704 int type = group.getType();
3705
3706 if (type == 4) {
3707 iterator.remove();
3708
3709 continue;
3710 }
3711
3712 if ((types != null) && !types.contains(type)) {
3713 iterator.remove();
3714
3715 continue;
3716 }
3717 }
3718
3719
3720
3721 RolePermissions rolePermissions = (RolePermissions)params.remove(
3722 "rolePermissions");
3723
3724 if (rolePermissions != null) {
3725 ResourceAction resourceAction =
3726 resourceActionLocalService.fetchResourceAction(
3727 rolePermissions.getName(), rolePermissions.getActionId());
3728
3729 if (resourceAction != null) {
3730 Set<Group> rolePermissionsGroups = new HashSet<>();
3731
3732 if (resourceBlockLocalService.isSupported(
3733 rolePermissions.getName())) {
3734
3735 List<ResourceTypePermission> resourceTypePermissions =
3736 resourceTypePermissionPersistence.findByRoleId(
3737 rolePermissions.getRoleId());
3738
3739 for (ResourceTypePermission resourceTypePermission :
3740 resourceTypePermissions) {
3741
3742 if ((resourceTypePermission.getCompanyId() ==
3743 companyId) &&
3744 Validator.equals(
3745 rolePermissions.getName(),
3746 resourceTypePermission.getName()) &&
3747 resourceTypePermission.hasAction(resourceAction)) {
3748
3749 Group group = groupPersistence.fetchByPrimaryKey(
3750 resourceTypePermission.getGroupId());
3751
3752 if (group != null) {
3753 rolePermissionsGroups.add(group);
3754 }
3755 }
3756 }
3757 }
3758 else {
3759 List<ResourcePermission> resourcePermissions =
3760 resourcePermissionPersistence.findByC_N_S(
3761 companyId, rolePermissions.getName(),
3762 rolePermissions.getScope());
3763
3764 for (ResourcePermission resourcePermission :
3765 resourcePermissions) {
3766
3767 if ((resourcePermission.getRoleId() ==
3768 rolePermissions.getRoleId()) &&
3769 resourcePermission.hasAction(
3770 resourceAction)) {
3771
3772 Group group = groupPersistence.fetchByPrimaryKey(
3773 GetterUtil.getLong(
3774 resourcePermission.getPrimKey()));
3775
3776 if (group != null) {
3777 rolePermissionsGroups.add(group);
3778 }
3779 }
3780 }
3781 }
3782
3783 groups.retainAll(rolePermissionsGroups);
3784 }
3785 }
3786
3787
3788
3789 Long roleId = (Long)params.remove("groupsRoles");
3790
3791 if (roleId != null) {
3792 groups.retainAll(rolePersistence.getGroups(roleId));
3793 }
3794
3795 if (userId == null) {
3796 return groups;
3797 }
3798
3799
3800
3801 Set<Group> joinedGroups = new HashSet<>(
3802 userPersistence.getGroups(userId));
3803
3804 boolean inherit = GetterUtil.getBoolean(params.remove("inherit"), true);
3805
3806 if (inherit) {
3807
3808
3809
3810 long[] organizationIds = userPersistence.getOrganizationPrimaryKeys(
3811 userId);
3812
3813 for (long organizationId : organizationIds) {
3814 for (Group group : groups) {
3815 if (organizationId == group.getClassPK()) {
3816 joinedGroups.add(group);
3817 }
3818 }
3819 }
3820
3821
3822
3823 for (long organizationId : organizationIds) {
3824 joinedGroups.addAll(
3825 organizationPersistence.getGroups(organizationId));
3826 }
3827
3828
3829
3830 long[] userGroupIds = userPersistence.getUserGroupPrimaryKeys(
3831 userId);
3832
3833 for (long userGroupId : userGroupIds) {
3834 joinedGroups.addAll(
3835 userGroupPersistence.getGroups(userGroupId));
3836 }
3837 }
3838
3839 if (_log.isDebugEnabled() && !params.isEmpty()) {
3840 _log.debug("Unprocessed parameters " + MapUtil.toString(params));
3841 }
3842
3843 if (joinedGroups.size() > groups.size()) {
3844 groups.retainAll(joinedGroups);
3845
3846 return groups;
3847 }
3848 else {
3849 joinedGroups.retainAll(groups);
3850
3851 return joinedGroups;
3852 }
3853 }
3854
3855 protected long[] getClassNameIds() {
3856 if (_classNameIds == null) {
3857 _classNameIds = new long[] {
3858 classNameLocalService.getClassNameId(Group.class),
3859 classNameLocalService.getClassNameId(Organization.class)
3860 };
3861 }
3862
3863 return _classNameIds;
3864 }
3865
3866 protected String getFriendlyURL(
3867 long companyId, long groupId, long classNameId, long classPK,
3868 String friendlyName, String friendlyURL)
3869 throws PortalException {
3870
3871 friendlyURL = getFriendlyURL(friendlyURL);
3872
3873 if (Validator.isNotNull(friendlyURL)) {
3874 return friendlyURL;
3875 }
3876
3877 friendlyURL = StringPool.SLASH + getFriendlyURL(friendlyName);
3878
3879 String originalFriendlyURL = friendlyURL;
3880
3881 for (int i = 1;; i++) {
3882 try {
3883 validateFriendlyURL(
3884 companyId, groupId, classNameId, classPK, friendlyURL);
3885
3886 break;
3887 }
3888 catch (GroupFriendlyURLException gfurle) {
3889 int type = gfurle.getType();
3890
3891 if (type == GroupFriendlyURLException.DUPLICATE) {
3892 friendlyURL = originalFriendlyURL + i;
3893 }
3894 else {
3895 friendlyURL = StringPool.SLASH + classPK;
3896
3897 break;
3898 }
3899 }
3900 }
3901
3902 return friendlyURL;
3903 }
3904
3905 protected String getFriendlyURL(String friendlyURL) {
3906 return FriendlyURLNormalizerUtil.normalize(friendlyURL);
3907 }
3908
3909 protected String getOrgGroupName(String name) {
3910 return name + ORGANIZATION_NAME_SUFFIX;
3911 }
3912
3913 protected List<PortletDataHandler> getPortletDataHandlers(Group group) {
3914 List<Portlet> portlets = portletLocalService.getPortlets(
3915 group.getCompanyId());
3916
3917 List<PortletDataHandler> portletDataHandlers = new ArrayList<>(
3918 portlets.size());
3919
3920 for (Portlet portlet : portlets) {
3921 if (!portlet.isActive()) {
3922 continue;
3923 }
3924
3925 PortletDataHandler portletDataHandler =
3926 portlet.getPortletDataHandlerInstance();
3927
3928 if ((portletDataHandler != null) &&
3929 !portletDataHandler.isDataPortalLevel()) {
3930
3931 portletDataHandlers.add(portletDataHandler);
3932 }
3933 }
3934
3935 return portletDataHandlers;
3936 }
3937
3938 protected String[] getSearchNames(long companyId, String name) {
3939 if (Validator.isNull(name)) {
3940 return new String[] {null};
3941 }
3942
3943 Company company = companyPersistence.fetchByPrimaryKey(companyId);
3944
3945 if (company == null) {
3946 return CustomSQLUtil.keywords(name);
3947 }
3948
3949 Account account = accountPersistence.fetchByPrimaryKey(
3950 company.getAccountId());
3951
3952 if (account == null) {
3953 return CustomSQLUtil.keywords(name);
3954 }
3955
3956 String companyName = account.getName();
3957
3958 if (StringUtil.wildcardMatches(
3959 companyName, name, CharPool.UNDERLINE, CharPool.PERCENT,
3960 CharPool.BACK_SLASH, false)) {
3961
3962 String[] searchNames = CustomSQLUtil.keywords(name);
3963
3964 String guestName = StringUtil.quote(
3965 StringUtil.toLowerCase(GroupConstants.GUEST),
3966 StringPool.PERCENT);
3967
3968 return ArrayUtil.append(searchNames, guestName);
3969 }
3970
3971 return CustomSQLUtil.keywords(name);
3972 }
3973
3974 protected void initImportLARFile() {
3975 String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
3976
3977 if (_log.isDebugEnabled()) {
3978 _log.debug("Reading public LAR file " + publicLARFileName);
3979 }
3980
3981 if (Validator.isNotNull(publicLARFileName)) {
3982 publicLARFile = new File(publicLARFileName);
3983
3984 if (!publicLARFile.exists()) {
3985 _log.error(
3986 "Public LAR file " + publicLARFile + " does not exist");
3987
3988 publicLARFile = null;
3989 }
3990 else {
3991 if (_log.isDebugEnabled()) {
3992 _log.debug("Using public LAR file " + publicLARFileName);
3993 }
3994 }
3995 }
3996 }
3997
3998 protected void initUserPersonalSitePermissions(Group group)
3999 throws PortalException {
4000
4001
4002
4003 Role role = roleLocalService.getRole(
4004 group.getCompanyId(), RoleConstants.USER);
4005
4006 setRolePermissions(
4007 group, role, Layout.class.getName(),
4008 new String[] {ActionKeys.VIEW});
4009
4010 setRolePermissions(
4011 group, role, "com.liferay.portlet.blogs",
4012 new String[] {
4013 ActionKeys.ADD_ENTRY, ActionKeys.PERMISSIONS,
4014 ActionKeys.SUBSCRIBE
4015 });
4016
4017
4018
4019 role = roleLocalService.getRole(
4020 group.getCompanyId(), RoleConstants.POWER_USER);
4021
4022 List<Portlet> portlets = portletLocalService.getPortlets(
4023 group.getCompanyId(), false, false);
4024
4025 for (Portlet portlet : portlets) {
4026 List<String> actions =
4027 ResourceActionsUtil.getPortletResourceActions(
4028 portlet.getPortletId());
4029
4030 String controlPanelEntryCategory = GetterUtil.getString(
4031 portlet.getControlPanelEntryCategory());
4032
4033 if (actions.contains(ActionKeys.ACCESS_IN_CONTROL_PANEL) &&
4034 controlPanelEntryCategory.startsWith(
4035 PortletCategoryKeys.SITE_ADMINISTRATION)) {
4036
4037 setRolePermissions(
4038 group, role, portlet.getPortletId(),
4039 new String[] {ActionKeys.ACCESS_IN_CONTROL_PANEL});
4040 }
4041 }
4042
4043 setRolePermissions(
4044 group, role, Group.class.getName(),
4045 new String[] {
4046 ActionKeys.MANAGE_LAYOUTS, ActionKeys.VIEW_SITE_ADMINISTRATION
4047 });
4048
4049 setRolePermissions(group, role, "com.liferay.portlet.asset");
4050 setRolePermissions(group, role, "com.liferay.portlet.blogs");
4051 setRolePermissions(group, role, "com.liferay.portlet.bookmarks");
4052 setRolePermissions(group, role, "com.liferay.portlet.documentlibrary");
4053 setRolePermissions(group, role, "com.liferay.portlet.imagegallery");
4054 setRolePermissions(group, role, "com.liferay.portlet.journal");
4055 setRolePermissions(group, role, "com.liferay.portlet.messageboards");
4056 setRolePermissions(group, role, "com.liferay.portlet.wiki");
4057 }
4058
4059 protected boolean isParentGroup(long parentGroupId, long groupId)
4060 throws PortalException {
4061
4062
4063
4064 if (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4065 return false;
4066 }
4067
4068 Group group = groupPersistence.findByPrimaryKey(groupId);
4069
4070 String treePath = group.getTreePath();
4071
4072 if (treePath.contains(
4073 StringPool.SLASH + parentGroupId + StringPool.SLASH)) {
4074
4075 return true;
4076 }
4077 else {
4078 return false;
4079 }
4080 }
4081
4082 protected boolean isStaging(ServiceContext serviceContext) {
4083 if (serviceContext != null) {
4084 return ParamUtil.getBoolean(serviceContext, "staging");
4085 }
4086
4087 return false;
4088 }
4089
4090 protected boolean isUseComplexSQL(long[] classNameIds) {
4091 if (ArrayUtil.isEmpty(classNameIds)) {
4092 return true;
4093 }
4094
4095 if (_complexSQLClassNameIds == null) {
4096 String[] complexSQLClassNames =
4097 PropsValues.GROUPS_COMPLEX_SQL_CLASS_NAMES;
4098
4099 long[] complexSQLClassNameIds =
4100 new long[complexSQLClassNames.length];
4101
4102 for (int i = 0; i < complexSQLClassNames.length; i++) {
4103 String complexSQLClassName = complexSQLClassNames[i];
4104
4105 complexSQLClassNameIds[i] =
4106 classNameLocalService.getClassNameId(complexSQLClassName);
4107 }
4108
4109 _complexSQLClassNameIds = complexSQLClassNameIds;
4110 }
4111
4112 for (long classNameId : classNameIds) {
4113 if (ArrayUtil.contains(_complexSQLClassNameIds, classNameId)) {
4114 return true;
4115 }
4116 }
4117
4118 return false;
4119 }
4120
4121 protected boolean matches(String s, String[] keywords) {
4122 if ((keywords == null) ||
4123 ((keywords.length == 1) && (keywords[0] == null))) {
4124
4125 return true;
4126 }
4127
4128 for (String keyword : keywords) {
4129 if (StringUtil.wildcardMatches(
4130 s, keyword, CharPool.UNDERLINE, CharPool.PERCENT,
4131 CharPool.BACK_SLASH, false)) {
4132
4133 return true;
4134 }
4135 }
4136
4137 return false;
4138 }
4139
4140 protected void setCompanyPermissions(
4141 Role role, String name, String[] actionIds)
4142 throws PortalException {
4143
4144 if (resourceBlockLocalService.isSupported(name)) {
4145 resourceBlockLocalService.setCompanyScopePermissions(
4146 role.getCompanyId(), name, role.getRoleId(),
4147 Arrays.asList(actionIds));
4148 }
4149 else {
4150 resourcePermissionLocalService.setResourcePermissions(
4151 role.getCompanyId(), name, ResourceConstants.SCOPE_COMPANY,
4152 String.valueOf(role.getCompanyId()), role.getRoleId(),
4153 actionIds);
4154 }
4155 }
4156
4157 protected void setRolePermissions(Group group, Role role, String name)
4158 throws PortalException {
4159
4160 List<String> actions = ResourceActionsUtil.getModelResourceActions(
4161 name);
4162
4163 setRolePermissions(
4164 group, role, name, actions.toArray(new String[actions.size()]));
4165 }
4166
4167 protected void setRolePermissions(
4168 Group group, Role role, String name, String[] actionIds)
4169 throws PortalException {
4170
4171 if (resourceBlockLocalService.isSupported(name)) {
4172 resourceBlockLocalService.setGroupScopePermissions(
4173 role.getCompanyId(), group.getGroupId(), name, role.getRoleId(),
4174 Arrays.asList(actionIds));
4175 }
4176 else {
4177 resourcePermissionLocalService.setResourcePermissions(
4178 group.getCompanyId(), name, ResourceConstants.SCOPE_GROUP,
4179 String.valueOf(group.getGroupId()), role.getRoleId(),
4180 actionIds);
4181 }
4182 }
4183
4184 protected List<Group> sort(
4185 Collection<Group> groups, int start, int end,
4186 OrderByComparator<Group> obc) {
4187
4188 if (obc == null) {
4189 obc = new GroupNameComparator(true);
4190 }
4191
4192 List<Group> groupList = null;
4193
4194 if (groups instanceof List) {
4195 groupList = (List<Group>)groups;
4196 }
4197 else {
4198 groupList = new ArrayList<>(groups);
4199 }
4200
4201 Collections.sort(groupList, obc);
4202
4203 return Collections.unmodifiableList(
4204 ListUtil.subList(groupList, start, end));
4205 }
4206
4207 protected void unscheduleStaging(Group group) {
4208 try {
4209
4210
4211
4212 String groupName = StagingUtil.getSchedulerGroupName(
4213 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
4214
4215 SchedulerEngineHelperUtil.delete(groupName, StorageType.PERSISTED);
4216
4217 long liveGroupId = 0;
4218 long stagingGroupId = 0;
4219
4220 if (group.isStagingGroup()) {
4221 liveGroupId = group.getLiveGroupId();
4222
4223 stagingGroupId = group.getGroupId();
4224 }
4225 else if (group.hasStagingGroup()) {
4226 liveGroupId = group.getGroupId();
4227
4228 stagingGroupId = group.getStagingGroup().getGroupId();
4229 }
4230
4231 if ((liveGroupId != 0) && (stagingGroupId != 0)) {
4232
4233
4234
4235 groupName = StagingUtil.getSchedulerGroupName(
4236 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
4237
4238 SchedulerEngineHelperUtil.delete(
4239 groupName, StorageType.PERSISTED);
4240
4241
4242
4243 groupName = StagingUtil.getSchedulerGroupName(
4244 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
4245
4246 SchedulerEngineHelperUtil.delete(
4247 groupName, StorageType.PERSISTED);
4248 }
4249 }
4250 catch (Exception e) {
4251 _log.error(
4252 "Unable to unschedule events for group: " + group.getGroupId());
4253 }
4254 }
4255
4256 protected void validateFriendlyURL(
4257 long companyId, long groupId, long classNameId, long classPK,
4258 String friendlyURL)
4259 throws PortalException {
4260
4261 Company company = companyPersistence.findByPrimaryKey(companyId);
4262
4263 if (company.isSystem()) {
4264 return;
4265 }
4266
4267 if (Validator.isNull(friendlyURL)) {
4268 return;
4269 }
4270
4271 int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
4272
4273 if (exceptionType != -1) {
4274 throw new GroupFriendlyURLException(exceptionType);
4275 }
4276
4277 Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
4278
4279 if ((group != null) && (group.getGroupId() != groupId)) {
4280 GroupFriendlyURLException gfurle = new GroupFriendlyURLException(
4281 GroupFriendlyURLException.DUPLICATE);
4282
4283 gfurle.setDuplicateClassPK(group.getGroupId());
4284 gfurle.setDuplicateClassName(Group.class.getName());
4285
4286 throw gfurle;
4287 }
4288
4289 String groupIdFriendlyURL = friendlyURL.substring(1);
4290
4291 if (Validator.isNumber(groupIdFriendlyURL)) {
4292 long groupClassNameId = classNameLocalService.getClassNameId(
4293 Group.class);
4294
4295 if (((classNameId != groupClassNameId) &&
4296 !groupIdFriendlyURL.equals(String.valueOf(classPK)) &&
4297 !PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC) ||
4298 ((classNameId == groupClassNameId) &&
4299 !groupIdFriendlyURL.equals(String.valueOf(groupId)))) {
4300
4301 GroupFriendlyURLException gfurle =
4302 new GroupFriendlyURLException(
4303 GroupFriendlyURLException.POSSIBLE_DUPLICATE);
4304
4305 gfurle.setKeywordConflict(groupIdFriendlyURL);
4306
4307 throw gfurle;
4308 }
4309 }
4310
4311 String screenName = friendlyURL.substring(1);
4312
4313 User user = userPersistence.fetchByC_SN(companyId, screenName);
4314
4315 if (user != null) {
4316 long userClassNameId = classNameLocalService.getClassNameId(
4317 User.class);
4318
4319 if ((classNameId == userClassNameId) &&
4320 (classPK == user.getUserId())) {
4321 }
4322 else {
4323 GroupFriendlyURLException gfurle =
4324 new GroupFriendlyURLException(
4325 GroupFriendlyURLException.DUPLICATE);
4326
4327 gfurle.setDuplicateClassPK(user.getUserId());
4328 gfurle.setDuplicateClassName(User.class.getName());
4329
4330 throw gfurle;
4331 }
4332 }
4333
4334 if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
4335 throw new GroupFriendlyURLException(
4336 GroupFriendlyURLException.TOO_DEEP);
4337 }
4338 }
4339
4340 protected void validateGroupKey(
4341 long groupId, long companyId, String groupKey, boolean site)
4342 throws PortalException {
4343
4344 if (Validator.isNull(groupKey) || Validator.isNumber(groupKey) ||
4345 groupKey.contains(StringPool.STAR) ||
4346 groupKey.contains(ORGANIZATION_NAME_SUFFIX)) {
4347
4348 throw new GroupKeyException();
4349 }
4350
4351 try {
4352 Group group = groupFinder.findByC_GK(companyId, groupKey);
4353
4354 if ((groupId <= 0) || (group.getGroupId() != groupId)) {
4355 throw new DuplicateGroupException("{groupId=" + groupId + "}");
4356 }
4357 }
4358 catch (NoSuchGroupException nsge) {
4359 }
4360
4361 if (site) {
4362 Company company = companyLocalService.getCompany(companyId);
4363
4364 if (groupKey.equals(company.getName())) {
4365 throw new DuplicateGroupException();
4366 }
4367 }
4368 }
4369
4370 protected void validateInheritContent(
4371 long parentGroupId, boolean inheritContent)
4372 throws GroupInheritContentException {
4373
4374 if (!inheritContent) {
4375 return;
4376 }
4377
4378 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4379 throw new GroupInheritContentException();
4380 }
4381
4382 Group parentGroup = groupPersistence.fetchByPrimaryKey(parentGroupId);
4383
4384 if (parentGroup.isInheritContent()) {
4385 throw new GroupInheritContentException();
4386 }
4387 }
4388
4389 protected void validateLanguageIds(
4390 String defaultLanguageId, String languageIds)
4391 throws PortalException {
4392
4393 String[] languageIdsArray = StringUtil.split(languageIds);
4394
4395 for (String languageId : languageIdsArray) {
4396 if (!LanguageUtil.isAvailableLocale(
4397 LocaleUtil.fromLanguageId(languageId))) {
4398
4399 LocaleException le = new LocaleException(
4400 LocaleException.TYPE_DISPLAY_SETTINGS);
4401
4402 le.setSourceAvailableLocales(
4403 LanguageUtil.getAvailableLocales());
4404 le.setTargetAvailableLocales(
4405 Arrays.asList(
4406 LocaleUtil.fromLanguageIds(languageIdsArray)));
4407
4408 throw le;
4409 }
4410 }
4411
4412 if (!ArrayUtil.contains(languageIdsArray, defaultLanguageId)) {
4413 LocaleException le = new LocaleException(
4414 LocaleException.TYPE_DEFAULT);
4415
4416 le.setSourceAvailableLocales(LanguageUtil.getAvailableLocales());
4417 le.setTargetAvailableLocales(
4418 Arrays.asList(LocaleUtil.fromLanguageIds(languageIdsArray)));
4419
4420 throw le;
4421 }
4422 }
4423
4424 protected void validateParentGroup(long groupId, long parentGroupId)
4425 throws PortalException {
4426
4427 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4428 return;
4429 }
4430
4431 if (groupId == parentGroupId) {
4432 throw new GroupParentException.MustNotBeOwnParent(groupId);
4433 }
4434
4435 Group group = groupPersistence.fetchByPrimaryKey(groupId);
4436
4437 if (group == null) {
4438 return;
4439 }
4440
4441 if ((groupId > 0) &&
4442 (parentGroupId != GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
4443
4444
4445
4446 if (isParentGroup(groupId, parentGroupId)) {
4447 throw new GroupParentException.MustNotHaveChildParent(
4448 groupId, parentGroupId);
4449 }
4450 }
4451
4452 Group parentGroup = groupPersistence.findByPrimaryKey(parentGroupId);
4453
4454 if (group.isStagingGroup()) {
4455 long stagingGroupId = parentGroup.getStagingGroup().getGroupId();
4456
4457 if (groupId == stagingGroupId) {
4458 throw new GroupParentException.MustNotHaveStagingParent(
4459 groupId, stagingGroupId);
4460 }
4461 }
4462 }
4463
4464 protected File publicLARFile;
4465
4466 private static final Log _log = LogFactoryUtil.getLog(
4467 GroupLocalServiceImpl.class);
4468
4469 private volatile long[] _classNameIds;
4470 private volatile long[] _complexSQLClassNameIds;
4471 private final Map<String, Group> _systemGroupsMap = new HashMap<>();
4472
4473 }