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