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.PortletKeys;
100 import com.liferay.portal.util.PropsUtil;
101 import com.liferay.portal.util.PropsValues;
102 import com.liferay.portal.util.comparator.GroupIdComparator;
103 import com.liferay.portal.util.comparator.GroupNameComparator;
104 import com.liferay.portlet.exportimport.configuration.ExportImportConfigurationConstants;
105 import com.liferay.portlet.exportimport.configuration.ExportImportConfigurationSettingsMapFactory;
106 import com.liferay.portlet.exportimport.lar.PortletDataContext;
107 import com.liferay.portlet.exportimport.lar.PortletDataContextFactoryUtil;
108 import com.liferay.portlet.exportimport.lar.PortletDataHandler;
109 import com.liferay.portlet.exportimport.lar.PortletDataHandlerKeys;
110 import com.liferay.portlet.exportimport.model.ExportImportConfiguration;
111 import com.liferay.portlet.exportimport.staging.StagingConstants;
112 import com.liferay.portlet.exportimport.staging.StagingUtil;
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 (Validator.isNotNull(
3419 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
3420
3421 layoutSet.setWapThemeId(
3422 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
3423
3424 updateLayoutSet = true;
3425 }
3426
3427 if (Validator.isNotNull(
3428 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
3429
3430 layoutSet.setWapColorSchemeId(
3431 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
3432
3433 updateLayoutSet = true;
3434 }
3435
3436 if (updateLayoutSet) {
3437 layoutSetLocalService.updateLayoutSet(layoutSet);
3438 }
3439 }
3440
3441 protected void addDefaultGuestPublicLayouts(Group group)
3442 throws PortalException {
3443
3444 if (publicLARFile != null) {
3445 addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
3446 }
3447 else {
3448 addDefaultGuestPublicLayoutByProperties(group);
3449 }
3450 }
3451
3452 protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
3453 throws PortalException {
3454
3455 User defaultUser = userLocalService.getDefaultUser(
3456 group.getCompanyId());
3457
3458 Map<String, String[]> parameterMap = new HashMap<>();
3459
3460 parameterMap.put(
3461 PortletDataHandlerKeys.PERMISSIONS,
3462 new String[] {Boolean.TRUE.toString()});
3463 parameterMap.put(
3464 PortletDataHandlerKeys.PORTLET_CONFIGURATION,
3465 new String[] {Boolean.TRUE.toString()});
3466 parameterMap.put(
3467 PortletDataHandlerKeys.PORTLET_DATA,
3468 new String[] {Boolean.TRUE.toString()});
3469 parameterMap.put(
3470 PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
3471 new String[] {Boolean.TRUE.toString()});
3472
3473 Map<String, Serializable> importLayoutSettingsMap =
3474 ExportImportConfigurationSettingsMapFactory.
3475 buildImportLayoutSettingsMap(
3476 defaultUser, group.getGroupId(), false, null, parameterMap);
3477
3478 ExportImportConfiguration exportImportConfiguration =
3479 exportImportConfigurationLocalService.
3480 addDraftExportImportConfiguration(
3481 defaultUser.getUserId(),
3482 ExportImportConfigurationConstants.TYPE_IMPORT_LAYOUT,
3483 importLayoutSettingsMap);
3484
3485 exportImportLocalService.importLayouts(
3486 exportImportConfiguration, larFile);
3487 }
3488
3489 protected void addPortletDefaultData(Group group) throws PortalException {
3490 PortletDataContext portletDataContext =
3491 PortletDataContextFactoryUtil.createPreparePortletDataContext(
3492 group.getCompanyId(), group.getGroupId(), null, null);
3493
3494 List<PortletDataHandler> portletDataHandlers = getPortletDataHandlers(
3495 group);
3496
3497 for (PortletDataHandler portletDataHandler : portletDataHandlers) {
3498 try {
3499 portletDataHandler.addDefaultData(
3500 portletDataContext, portletDataHandler.getPortletId(),
3501 null);
3502 }
3503 catch (Exception e) {
3504 _log.error(
3505 "Unable to add default data for portlet " +
3506 portletDataHandler.getPortletId() + " in group " +
3507 group.getGroupId());
3508
3509 if (portletDataHandler.isRollbackOnException()) {
3510 throw new SystemException(e);
3511 }
3512 }
3513 }
3514 }
3515
3516 protected void deletePortletData(Group group) throws PortalException {
3517 PortletDataContext portletDataContext =
3518 PortletDataContextFactoryUtil.createPreparePortletDataContext(
3519 group.getCompanyId(), group.getGroupId(), null, null);
3520
3521 List<PortletDataHandler> portletDataHandlers = getPortletDataHandlers(
3522 group);
3523
3524 for (PortletDataHandler portletDataHandler : portletDataHandlers) {
3525 try {
3526 portletDataHandler.deleteData(
3527 portletDataContext, portletDataHandler.getPortletId(),
3528 null);
3529 }
3530 catch (Exception e) {
3531 _log.error(
3532 "Unable to delete data for portlet " +
3533 portletDataHandler.getPortletId() + " in group " +
3534 group.getGroupId());
3535
3536 if (portletDataHandler.isRollbackOnException()) {
3537 throw new SystemException(e);
3538 }
3539 }
3540 }
3541 }
3542
3543 protected Collection<Group> doSearch(
3544 long companyId, long[] classNameIds, long parentGroupId, String[] names,
3545 String[] descriptions, LinkedHashMap<String, Object> params,
3546 boolean andOperator) {
3547
3548 boolean parentGroupIdEquals = true;
3549
3550 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
3551 parentGroupIdEquals = false;
3552 }
3553
3554 params = new LinkedHashMap<>(params);
3555
3556 Boolean active = (Boolean)params.remove("active");
3557 List<Long> excludedGroupIds = (List<Long>)params.remove(
3558 "excludedGroupIds");
3559 List<Group> groupsTree = (List<Group>)params.remove("groupsTree");
3560 Boolean manualMembership = (Boolean)params.remove("manualMembership");
3561 Integer membershipRestriction = (Integer)params.remove(
3562 "membershipRestriction");
3563 Boolean site = (Boolean)params.remove("site");
3564 List<Integer> types = (List<Integer>)params.remove("types");
3565
3566 Collection<Group> groups = new HashSet<>();
3567
3568 Long userId = (Long)params.remove("usersGroups");
3569
3570 for (long classNameId : classNameIds) {
3571 groups.addAll(groupPersistence.findByC_C(companyId, classNameId));
3572 }
3573
3574 Iterator<Group> iterator = groups.iterator();
3575
3576 while (iterator.hasNext()) {
3577 Group group = iterator.next();
3578
3579
3580
3581 long liveGroupId = group.getLiveGroupId();
3582
3583 if (liveGroupId != 0) {
3584 iterator.remove();
3585
3586 continue;
3587 }
3588
3589
3590
3591 long groupParentGroupId = group.getParentGroupId();
3592
3593 if ((parentGroupIdEquals &&
3594 (groupParentGroupId != parentGroupId)) ||
3595 (!parentGroupIdEquals &&
3596 (groupParentGroupId == parentGroupId))) {
3597
3598 iterator.remove();
3599
3600 continue;
3601 }
3602
3603
3604
3605 String groupKey = group.getGroupKey();
3606
3607 if (groupKey.equals(GroupConstants.CONTROL_PANEL)) {
3608 iterator.remove();
3609
3610 continue;
3611 }
3612
3613 boolean containsName = matches(group.getNameCurrentValue(), names);
3614 boolean containsDescription = matches(
3615 group.getDescriptionCurrentValue(), descriptions);
3616
3617 if ((andOperator && (!containsName || !containsDescription)) ||
3618 (!andOperator && !containsName && !containsDescription)) {
3619
3620 iterator.remove();
3621
3622 continue;
3623 }
3624
3625
3626
3627 if (active != null) {
3628 if (active != group.isActive()) {
3629 iterator.remove();
3630
3631 continue;
3632 }
3633 }
3634
3635
3636
3637 if ((excludedGroupIds != null) &&
3638 excludedGroupIds.contains(group.getGroupId())) {
3639
3640 iterator.remove();
3641
3642 continue;
3643 }
3644
3645
3646
3647 if (groupsTree != null) {
3648 String treePath = group.getTreePath();
3649
3650 boolean matched = false;
3651
3652 for (Group groupTree : groupsTree) {
3653 String groupTreePath = StringUtil.quote(
3654 String.valueOf(groupTree.getGroupId()),
3655 StringPool.SLASH);
3656
3657 if (treePath.contains(groupTreePath)) {
3658 matched = true;
3659
3660 break;
3661 }
3662 }
3663
3664 if (!matched) {
3665 iterator.remove();
3666
3667 continue;
3668 }
3669 }
3670
3671
3672
3673 if ((manualMembership != null) &&
3674 (manualMembership != group.isManualMembership())) {
3675
3676 iterator.remove();
3677
3678 continue;
3679 }
3680
3681
3682
3683 if ((membershipRestriction != null) &&
3684 (membershipRestriction != group.getMembershipRestriction())) {
3685
3686 iterator.remove();
3687
3688 continue;
3689 }
3690
3691
3692
3693 if (site != null) {
3694 if (site != group.isSite()) {
3695 iterator.remove();
3696
3697 continue;
3698 }
3699 }
3700
3701
3702
3703 int type = group.getType();
3704
3705 if (type == 4) {
3706 iterator.remove();
3707
3708 continue;
3709 }
3710
3711 if ((types != null) && !types.contains(type)) {
3712 iterator.remove();
3713
3714 continue;
3715 }
3716 }
3717
3718
3719
3720 RolePermissions rolePermissions = (RolePermissions)params.remove(
3721 "rolePermissions");
3722
3723 if (rolePermissions != null) {
3724 ResourceAction resourceAction =
3725 resourceActionLocalService.fetchResourceAction(
3726 rolePermissions.getName(), rolePermissions.getActionId());
3727
3728 if (resourceAction != null) {
3729 Set<Group> rolePermissionsGroups = new HashSet<>();
3730
3731 if (resourceBlockLocalService.isSupported(
3732 rolePermissions.getName())) {
3733
3734 List<ResourceTypePermission> resourceTypePermissions =
3735 resourceTypePermissionPersistence.findByRoleId(
3736 rolePermissions.getRoleId());
3737
3738 for (ResourceTypePermission resourceTypePermission :
3739 resourceTypePermissions) {
3740
3741 if ((resourceTypePermission.getCompanyId() ==
3742 companyId) &&
3743 Validator.equals(
3744 rolePermissions.getName(),
3745 resourceTypePermission.getName()) &&
3746 resourceTypePermission.hasAction(resourceAction)) {
3747
3748 Group group = groupPersistence.fetchByPrimaryKey(
3749 resourceTypePermission.getGroupId());
3750
3751 if (group != null) {
3752 rolePermissionsGroups.add(group);
3753 }
3754 }
3755 }
3756 }
3757 else {
3758 List<ResourcePermission> resourcePermissions =
3759 resourcePermissionPersistence.findByC_N_S(
3760 companyId, rolePermissions.getName(),
3761 rolePermissions.getScope());
3762
3763 for (ResourcePermission resourcePermission :
3764 resourcePermissions) {
3765
3766 if ((resourcePermission.getRoleId() ==
3767 rolePermissions.getRoleId()) &&
3768 resourcePermission.hasAction(
3769 resourceAction)) {
3770
3771 Group group = groupPersistence.fetchByPrimaryKey(
3772 GetterUtil.getLong(
3773 resourcePermission.getPrimKey()));
3774
3775 if (group != null) {
3776 rolePermissionsGroups.add(group);
3777 }
3778 }
3779 }
3780 }
3781
3782 groups.retainAll(rolePermissionsGroups);
3783 }
3784 }
3785
3786
3787
3788 Long roleId = (Long)params.remove("groupsRoles");
3789
3790 if (roleId != null) {
3791 groups.retainAll(rolePersistence.getGroups(roleId));
3792 }
3793
3794 if (userId == null) {
3795 return groups;
3796 }
3797
3798
3799
3800 Set<Group> joinedGroups = new HashSet<>(
3801 userPersistence.getGroups(userId));
3802
3803 boolean inherit = GetterUtil.getBoolean(params.remove("inherit"), true);
3804
3805 if (inherit) {
3806
3807
3808
3809 long[] organizationIds = userPersistence.getOrganizationPrimaryKeys(
3810 userId);
3811
3812 for (long organizationId : organizationIds) {
3813 for (Group group : groups) {
3814 if (organizationId == group.getClassPK()) {
3815 joinedGroups.add(group);
3816 }
3817 }
3818 }
3819
3820
3821
3822 for (long organizationId : organizationIds) {
3823 joinedGroups.addAll(
3824 organizationPersistence.getGroups(organizationId));
3825 }
3826
3827
3828
3829 long[] userGroupIds = userPersistence.getUserGroupPrimaryKeys(
3830 userId);
3831
3832 for (long userGroupId : userGroupIds) {
3833 joinedGroups.addAll(
3834 userGroupPersistence.getGroups(userGroupId));
3835 }
3836 }
3837
3838 if (_log.isDebugEnabled() && !params.isEmpty()) {
3839 _log.debug("Unprocessed parameters " + MapUtil.toString(params));
3840 }
3841
3842 if (joinedGroups.size() > groups.size()) {
3843 groups.retainAll(joinedGroups);
3844
3845 return groups;
3846 }
3847 else {
3848 joinedGroups.retainAll(groups);
3849
3850 return joinedGroups;
3851 }
3852 }
3853
3854 protected long[] getClassNameIds() {
3855 if (_classNameIds == null) {
3856 _classNameIds = new long[] {
3857 classNameLocalService.getClassNameId(Group.class),
3858 classNameLocalService.getClassNameId(Organization.class)
3859 };
3860 }
3861
3862 return _classNameIds;
3863 }
3864
3865 protected String getFriendlyURL(
3866 long companyId, long groupId, long classNameId, long classPK,
3867 String friendlyName, String friendlyURL)
3868 throws PortalException {
3869
3870 friendlyURL = getFriendlyURL(friendlyURL);
3871
3872 if (Validator.isNotNull(friendlyURL)) {
3873 return friendlyURL;
3874 }
3875
3876 friendlyURL = StringPool.SLASH + getFriendlyURL(friendlyName);
3877
3878 String originalFriendlyURL = friendlyURL;
3879
3880 for (int i = 1;; i++) {
3881 try {
3882 validateFriendlyURL(
3883 companyId, groupId, classNameId, classPK, friendlyURL);
3884
3885 break;
3886 }
3887 catch (GroupFriendlyURLException gfurle) {
3888 int type = gfurle.getType();
3889
3890 if (type == GroupFriendlyURLException.DUPLICATE) {
3891 friendlyURL = originalFriendlyURL + i;
3892 }
3893 else {
3894 friendlyURL = StringPool.SLASH + classPK;
3895
3896 break;
3897 }
3898 }
3899 }
3900
3901 return friendlyURL;
3902 }
3903
3904 protected String getFriendlyURL(String friendlyURL) {
3905 return FriendlyURLNormalizerUtil.normalize(friendlyURL);
3906 }
3907
3908 protected String getOrgGroupName(String name) {
3909 return name + ORGANIZATION_NAME_SUFFIX;
3910 }
3911
3912 protected List<PortletDataHandler> getPortletDataHandlers(Group group) {
3913 List<Portlet> portlets = portletLocalService.getPortlets(
3914 group.getCompanyId());
3915
3916 List<PortletDataHandler> portletDataHandlers = new ArrayList<>(
3917 portlets.size());
3918
3919 for (Portlet portlet : portlets) {
3920 if (!portlet.isActive()) {
3921 continue;
3922 }
3923
3924 PortletDataHandler portletDataHandler =
3925 portlet.getPortletDataHandlerInstance();
3926
3927 if ((portletDataHandler != null) &&
3928 !portletDataHandler.isDataPortalLevel()) {
3929
3930 portletDataHandlers.add(portletDataHandler);
3931 }
3932 }
3933
3934 return portletDataHandlers;
3935 }
3936
3937 protected String[] getSearchNames(long companyId, String name) {
3938 if (Validator.isNull(name)) {
3939 return new String[] {null};
3940 }
3941
3942 Company company = companyPersistence.fetchByPrimaryKey(companyId);
3943
3944 if (company == null) {
3945 return CustomSQLUtil.keywords(name);
3946 }
3947
3948 Account account = accountPersistence.fetchByPrimaryKey(
3949 company.getAccountId());
3950
3951 if (account == null) {
3952 return CustomSQLUtil.keywords(name);
3953 }
3954
3955 String companyName = account.getName();
3956
3957 if (StringUtil.wildcardMatches(
3958 companyName, name, CharPool.UNDERLINE, CharPool.PERCENT,
3959 CharPool.BACK_SLASH, false)) {
3960
3961 String[] searchNames = CustomSQLUtil.keywords(name);
3962
3963 String guestName = StringUtil.quote(
3964 StringUtil.toLowerCase(GroupConstants.GUEST),
3965 StringPool.PERCENT);
3966
3967 return ArrayUtil.append(searchNames, guestName);
3968 }
3969
3970 return CustomSQLUtil.keywords(name);
3971 }
3972
3973 protected void initImportLARFile() {
3974 String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
3975
3976 if (_log.isDebugEnabled()) {
3977 _log.debug("Reading public LAR file " + publicLARFileName);
3978 }
3979
3980 if (Validator.isNotNull(publicLARFileName)) {
3981 publicLARFile = new File(publicLARFileName);
3982
3983 if (!publicLARFile.exists()) {
3984 _log.error(
3985 "Public LAR file " + publicLARFile + " does not exist");
3986
3987 publicLARFile = null;
3988 }
3989 else {
3990 if (_log.isDebugEnabled()) {
3991 _log.debug("Using public LAR file " + publicLARFileName);
3992 }
3993 }
3994 }
3995 }
3996
3997 protected void initUserPersonalSitePermissions(Group group)
3998 throws PortalException {
3999
4000
4001
4002 Role role = roleLocalService.getRole(
4003 group.getCompanyId(), RoleConstants.USER);
4004
4005 setRolePermissions(
4006 group, role, Layout.class.getName(),
4007 new String[] {ActionKeys.VIEW});
4008
4009
4010
4011 role = roleLocalService.getRole(
4012 group.getCompanyId(), RoleConstants.POWER_USER);
4013
4014 setRolePermissions(
4015 group, role, Group.class.getName(),
4016 new String[] {
4017 ActionKeys.MANAGE_LAYOUTS, ActionKeys.VIEW_SITE_ADMINISTRATION
4018 });
4019 }
4020
4021 protected boolean isParentGroup(long parentGroupId, long groupId)
4022 throws PortalException {
4023
4024
4025
4026 if (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4027 return false;
4028 }
4029
4030 Group group = groupPersistence.findByPrimaryKey(groupId);
4031
4032 String treePath = group.getTreePath();
4033
4034 if (treePath.contains(
4035 StringPool.SLASH + parentGroupId + StringPool.SLASH)) {
4036
4037 return true;
4038 }
4039 else {
4040 return false;
4041 }
4042 }
4043
4044 protected boolean isStaging(ServiceContext serviceContext) {
4045 if (serviceContext != null) {
4046 return ParamUtil.getBoolean(serviceContext, "staging");
4047 }
4048
4049 return false;
4050 }
4051
4052 protected boolean isUseComplexSQL(long[] classNameIds) {
4053 if (ArrayUtil.isEmpty(classNameIds)) {
4054 return true;
4055 }
4056
4057 if (_complexSQLClassNameIds == null) {
4058 String[] complexSQLClassNames =
4059 PropsValues.GROUPS_COMPLEX_SQL_CLASS_NAMES;
4060
4061 long[] complexSQLClassNameIds =
4062 new long[complexSQLClassNames.length];
4063
4064 for (int i = 0; i < complexSQLClassNames.length; i++) {
4065 String complexSQLClassName = complexSQLClassNames[i];
4066
4067 complexSQLClassNameIds[i] =
4068 classNameLocalService.getClassNameId(complexSQLClassName);
4069 }
4070
4071 _complexSQLClassNameIds = complexSQLClassNameIds;
4072 }
4073
4074 for (long classNameId : classNameIds) {
4075 if (ArrayUtil.contains(_complexSQLClassNameIds, classNameId)) {
4076 return true;
4077 }
4078 }
4079
4080 return false;
4081 }
4082
4083 protected boolean matches(String s, String[] keywords) {
4084 if ((keywords == null) ||
4085 ((keywords.length == 1) && (keywords[0] == null))) {
4086
4087 return true;
4088 }
4089
4090 for (String keyword : keywords) {
4091 if (StringUtil.wildcardMatches(
4092 s, keyword, CharPool.UNDERLINE, CharPool.PERCENT,
4093 CharPool.BACK_SLASH, false)) {
4094
4095 return true;
4096 }
4097 }
4098
4099 return false;
4100 }
4101
4102 protected void setCompanyPermissions(
4103 Role role, String name, String[] actionIds)
4104 throws PortalException {
4105
4106 if (resourceBlockLocalService.isSupported(name)) {
4107 resourceBlockLocalService.setCompanyScopePermissions(
4108 role.getCompanyId(), name, role.getRoleId(),
4109 Arrays.asList(actionIds));
4110 }
4111 else {
4112 resourcePermissionLocalService.setResourcePermissions(
4113 role.getCompanyId(), name, ResourceConstants.SCOPE_COMPANY,
4114 String.valueOf(role.getCompanyId()), role.getRoleId(),
4115 actionIds);
4116 }
4117 }
4118
4119 protected void setRolePermissions(Group group, Role role, String name)
4120 throws PortalException {
4121
4122 List<String> actions = ResourceActionsUtil.getModelResourceActions(
4123 name);
4124
4125 setRolePermissions(
4126 group, role, name, actions.toArray(new String[actions.size()]));
4127 }
4128
4129 protected void setRolePermissions(
4130 Group group, Role role, String name, String[] actionIds)
4131 throws PortalException {
4132
4133 if (resourceBlockLocalService.isSupported(name)) {
4134 resourceBlockLocalService.setGroupScopePermissions(
4135 role.getCompanyId(), group.getGroupId(), name, role.getRoleId(),
4136 Arrays.asList(actionIds));
4137 }
4138 else {
4139 resourcePermissionLocalService.setResourcePermissions(
4140 group.getCompanyId(), name, ResourceConstants.SCOPE_GROUP,
4141 String.valueOf(group.getGroupId()), role.getRoleId(),
4142 actionIds);
4143 }
4144 }
4145
4146 protected List<Group> sort(
4147 Collection<Group> groups, int start, int end,
4148 OrderByComparator<Group> obc) {
4149
4150 if (obc == null) {
4151 obc = new GroupNameComparator(true);
4152 }
4153
4154 List<Group> groupList = null;
4155
4156 if (groups instanceof List) {
4157 groupList = (List<Group>)groups;
4158 }
4159 else {
4160 groupList = new ArrayList<>(groups);
4161 }
4162
4163 Collections.sort(groupList, obc);
4164
4165 return Collections.unmodifiableList(
4166 ListUtil.subList(groupList, start, end));
4167 }
4168
4169 protected void unscheduleStaging(Group group) {
4170 try {
4171
4172
4173
4174 String groupName = StagingUtil.getSchedulerGroupName(
4175 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
4176
4177 SchedulerEngineHelperUtil.delete(groupName, StorageType.PERSISTED);
4178
4179 long liveGroupId = 0;
4180 long stagingGroupId = 0;
4181
4182 if (group.isStagingGroup()) {
4183 liveGroupId = group.getLiveGroupId();
4184
4185 stagingGroupId = group.getGroupId();
4186 }
4187 else if (group.hasStagingGroup()) {
4188 liveGroupId = group.getGroupId();
4189
4190 stagingGroupId = group.getStagingGroup().getGroupId();
4191 }
4192
4193 if ((liveGroupId != 0) && (stagingGroupId != 0)) {
4194
4195
4196
4197 groupName = StagingUtil.getSchedulerGroupName(
4198 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
4199
4200 SchedulerEngineHelperUtil.delete(
4201 groupName, StorageType.PERSISTED);
4202
4203
4204
4205 groupName = StagingUtil.getSchedulerGroupName(
4206 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
4207
4208 SchedulerEngineHelperUtil.delete(
4209 groupName, StorageType.PERSISTED);
4210 }
4211 }
4212 catch (Exception e) {
4213 _log.error(
4214 "Unable to unschedule events for group: " + group.getGroupId());
4215 }
4216 }
4217
4218 protected void validateFriendlyURL(
4219 long companyId, long groupId, long classNameId, long classPK,
4220 String friendlyURL)
4221 throws PortalException {
4222
4223 Company company = companyPersistence.findByPrimaryKey(companyId);
4224
4225 if (company.isSystem()) {
4226 return;
4227 }
4228
4229 if (Validator.isNull(friendlyURL)) {
4230 return;
4231 }
4232
4233 int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
4234
4235 if (exceptionType != -1) {
4236 throw new GroupFriendlyURLException(exceptionType);
4237 }
4238
4239 Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
4240
4241 if ((group != null) && (group.getGroupId() != groupId)) {
4242 GroupFriendlyURLException gfurle = new GroupFriendlyURLException(
4243 GroupFriendlyURLException.DUPLICATE);
4244
4245 gfurle.setDuplicateClassPK(group.getGroupId());
4246 gfurle.setDuplicateClassName(Group.class.getName());
4247
4248 throw gfurle;
4249 }
4250
4251 String groupIdFriendlyURL = friendlyURL.substring(1);
4252
4253 if (Validator.isNumber(groupIdFriendlyURL)) {
4254 long groupClassNameId = classNameLocalService.getClassNameId(
4255 Group.class);
4256
4257 if (((classNameId != groupClassNameId) &&
4258 !groupIdFriendlyURL.equals(String.valueOf(classPK)) &&
4259 !PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC) ||
4260 ((classNameId == groupClassNameId) &&
4261 !groupIdFriendlyURL.equals(String.valueOf(groupId)))) {
4262
4263 GroupFriendlyURLException gfurle =
4264 new GroupFriendlyURLException(
4265 GroupFriendlyURLException.POSSIBLE_DUPLICATE);
4266
4267 gfurle.setKeywordConflict(groupIdFriendlyURL);
4268
4269 throw gfurle;
4270 }
4271 }
4272
4273 String screenName = friendlyURL.substring(1);
4274
4275 User user = userPersistence.fetchByC_SN(companyId, screenName);
4276
4277 if (user != null) {
4278 long userClassNameId = classNameLocalService.getClassNameId(
4279 User.class);
4280
4281 if ((classNameId == userClassNameId) &&
4282 (classPK == user.getUserId())) {
4283 }
4284 else {
4285 GroupFriendlyURLException gfurle =
4286 new GroupFriendlyURLException(
4287 GroupFriendlyURLException.DUPLICATE);
4288
4289 gfurle.setDuplicateClassPK(user.getUserId());
4290 gfurle.setDuplicateClassName(User.class.getName());
4291
4292 throw gfurle;
4293 }
4294 }
4295
4296 if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
4297 throw new GroupFriendlyURLException(
4298 GroupFriendlyURLException.TOO_DEEP);
4299 }
4300 }
4301
4302 protected void validateGroupKey(
4303 long groupId, long companyId, String groupKey, boolean site)
4304 throws PortalException {
4305
4306 if (Validator.isNull(groupKey) || Validator.isNumber(groupKey) ||
4307 groupKey.contains(StringPool.STAR) ||
4308 groupKey.contains(ORGANIZATION_NAME_SUFFIX)) {
4309
4310 throw new GroupKeyException();
4311 }
4312
4313 try {
4314 Group group = groupFinder.findByC_GK(companyId, groupKey);
4315
4316 if ((groupId <= 0) || (group.getGroupId() != groupId)) {
4317 throw new DuplicateGroupException("{groupId=" + groupId + "}");
4318 }
4319 }
4320 catch (NoSuchGroupException nsge) {
4321 }
4322
4323 if (site) {
4324 Company company = companyLocalService.getCompany(companyId);
4325
4326 if (groupKey.equals(company.getName())) {
4327 throw new DuplicateGroupException();
4328 }
4329 }
4330 }
4331
4332 protected void validateInheritContent(
4333 long parentGroupId, boolean inheritContent)
4334 throws GroupInheritContentException {
4335
4336 if (!inheritContent) {
4337 return;
4338 }
4339
4340 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4341 throw new GroupInheritContentException();
4342 }
4343
4344 Group parentGroup = groupPersistence.fetchByPrimaryKey(parentGroupId);
4345
4346 if (parentGroup.isInheritContent()) {
4347 throw new GroupInheritContentException();
4348 }
4349 }
4350
4351 protected void validateLanguageIds(
4352 String defaultLanguageId, String languageIds)
4353 throws PortalException {
4354
4355 String[] languageIdsArray = StringUtil.split(languageIds);
4356
4357 for (String languageId : languageIdsArray) {
4358 if (!LanguageUtil.isAvailableLocale(
4359 LocaleUtil.fromLanguageId(languageId))) {
4360
4361 LocaleException le = new LocaleException(
4362 LocaleException.TYPE_DISPLAY_SETTINGS);
4363
4364 le.setSourceAvailableLocales(
4365 LanguageUtil.getAvailableLocales());
4366 le.setTargetAvailableLocales(
4367 Arrays.asList(
4368 LocaleUtil.fromLanguageIds(languageIdsArray)));
4369
4370 throw le;
4371 }
4372 }
4373
4374 if (!ArrayUtil.contains(languageIdsArray, defaultLanguageId)) {
4375 LocaleException le = new LocaleException(
4376 LocaleException.TYPE_DEFAULT);
4377
4378 le.setSourceAvailableLocales(LanguageUtil.getAvailableLocales());
4379 le.setTargetAvailableLocales(
4380 Arrays.asList(LocaleUtil.fromLanguageIds(languageIdsArray)));
4381
4382 throw le;
4383 }
4384 }
4385
4386 protected void validateParentGroup(long groupId, long parentGroupId)
4387 throws PortalException {
4388
4389 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4390 return;
4391 }
4392
4393 if (groupId == parentGroupId) {
4394 throw new GroupParentException.MustNotBeOwnParent(groupId);
4395 }
4396
4397 Group group = groupPersistence.fetchByPrimaryKey(groupId);
4398
4399 if (group == null) {
4400 return;
4401 }
4402
4403 if ((groupId > 0) &&
4404 (parentGroupId != GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
4405
4406
4407
4408 if (isParentGroup(groupId, parentGroupId)) {
4409 throw new GroupParentException.MustNotHaveChildParent(
4410 groupId, parentGroupId);
4411 }
4412 }
4413
4414 Group parentGroup = groupPersistence.findByPrimaryKey(parentGroupId);
4415
4416 if (group.isStagingGroup()) {
4417 long stagingGroupId = parentGroup.getStagingGroup().getGroupId();
4418
4419 if (groupId == stagingGroupId) {
4420 throw new GroupParentException.MustNotHaveStagingParent(
4421 groupId, stagingGroupId);
4422 }
4423 }
4424 }
4425
4426 protected File publicLARFile;
4427
4428 private static final Log _log = LogFactoryUtil.getLog(
4429 GroupLocalServiceImpl.class);
4430
4431 private volatile long[] _classNameIds;
4432 private volatile long[] _complexSQLClassNameIds;
4433 private final Map<String, Group> _systemGroupsMap = new HashMap<>();
4434
4435 }