001
014
015 package com.liferay.portal.service.impl;
016
017 import com.liferay.portal.DuplicateGroupException;
018 import com.liferay.portal.GroupFriendlyURLException;
019 import com.liferay.portal.GroupInheritContentException;
020 import com.liferay.portal.GroupKeyException;
021 import com.liferay.portal.GroupParentException;
022 import com.liferay.portal.LocaleException;
023 import com.liferay.portal.NoSuchGroupException;
024 import com.liferay.portal.NoSuchLayoutSetException;
025 import com.liferay.portal.PendingBackgroundTaskException;
026 import com.liferay.portal.RequiredGroupException;
027 import com.liferay.portal.kernel.backgroundtask.BackgroundTaskConstants;
028 import com.liferay.portal.kernel.cache.ThreadLocalCachable;
029 import com.liferay.portal.kernel.dao.orm.QueryUtil;
030 import com.liferay.portal.kernel.exception.PortalException;
031 import com.liferay.portal.kernel.exception.SystemException;
032 import com.liferay.portal.kernel.language.LanguageUtil;
033 import com.liferay.portal.kernel.log.Log;
034 import com.liferay.portal.kernel.log.LogFactoryUtil;
035 import com.liferay.portal.kernel.messaging.DestinationNames;
036 import com.liferay.portal.kernel.scheduler.SchedulerEngineHelperUtil;
037 import com.liferay.portal.kernel.scheduler.StorageType;
038 import com.liferay.portal.kernel.spring.aop.Skip;
039 import com.liferay.portal.kernel.transaction.Propagation;
040 import com.liferay.portal.kernel.transaction.Transactional;
041 import com.liferay.portal.kernel.util.ArrayUtil;
042 import com.liferay.portal.kernel.util.CharPool;
043 import com.liferay.portal.kernel.util.Constants;
044 import com.liferay.portal.kernel.util.FileUtil;
045 import com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil;
046 import com.liferay.portal.kernel.util.GetterUtil;
047 import com.liferay.portal.kernel.util.GroupThreadLocal;
048 import com.liferay.portal.kernel.util.ListUtil;
049 import com.liferay.portal.kernel.util.LocaleUtil;
050 import com.liferay.portal.kernel.util.MapUtil;
051 import com.liferay.portal.kernel.util.OrderByComparator;
052 import com.liferay.portal.kernel.util.ParamUtil;
053 import com.liferay.portal.kernel.util.PropsKeys;
054 import com.liferay.portal.kernel.util.StringBundler;
055 import com.liferay.portal.kernel.util.StringPool;
056 import com.liferay.portal.kernel.util.StringUtil;
057 import com.liferay.portal.kernel.util.TreeModelTasksAdapter;
058 import com.liferay.portal.kernel.util.TreePathUtil;
059 import com.liferay.portal.kernel.util.UnicodeProperties;
060 import com.liferay.portal.kernel.util.Validator;
061 import com.liferay.portal.kernel.workflow.WorkflowConstants;
062 import com.liferay.portal.kernel.workflow.WorkflowHandler;
063 import com.liferay.portal.kernel.workflow.WorkflowHandlerRegistryUtil;
064 import com.liferay.portal.model.Account;
065 import com.liferay.portal.model.BackgroundTask;
066 import com.liferay.portal.model.Company;
067 import com.liferay.portal.model.Group;
068 import com.liferay.portal.model.GroupConstants;
069 import com.liferay.portal.model.Layout;
070 import com.liferay.portal.model.LayoutConstants;
071 import com.liferay.portal.model.LayoutPrototype;
072 import com.liferay.portal.model.LayoutSet;
073 import com.liferay.portal.model.LayoutSetPrototype;
074 import com.liferay.portal.model.LayoutTemplate;
075 import com.liferay.portal.model.LayoutTypePortlet;
076 import com.liferay.portal.model.Organization;
077 import com.liferay.portal.model.Portlet;
078 import com.liferay.portal.model.ResourceAction;
079 import com.liferay.portal.model.ResourceConstants;
080 import com.liferay.portal.model.ResourcePermission;
081 import com.liferay.portal.model.ResourceTypePermission;
082 import com.liferay.portal.model.Role;
083 import com.liferay.portal.model.RoleConstants;
084 import com.liferay.portal.model.User;
085 import com.liferay.portal.model.UserGroup;
086 import com.liferay.portal.model.UserGroupRole;
087 import com.liferay.portal.model.UserPersonalSite;
088 import com.liferay.portal.model.WorkflowDefinitionLink;
089 import com.liferay.portal.model.impl.LayoutImpl;
090 import com.liferay.portal.security.auth.CompanyThreadLocal;
091 import com.liferay.portal.security.permission.ActionKeys;
092 import com.liferay.portal.security.permission.PermissionCacheUtil;
093 import com.liferay.portal.security.permission.ResourceActionsUtil;
094 import com.liferay.portal.service.ServiceContext;
095 import com.liferay.portal.service.base.GroupLocalServiceBaseImpl;
096 import com.liferay.portal.theme.ThemeLoader;
097 import com.liferay.portal.theme.ThemeLoaderFactory;
098 import com.liferay.portal.util.PortalUtil;
099 import com.liferay.portal.util.PortletCategoryKeys;
100 import com.liferay.portal.util.PortletKeys;
101 import com.liferay.portal.util.PropsUtil;
102 import com.liferay.portal.util.PropsValues;
103 import com.liferay.portal.util.comparator.GroupIdComparator;
104 import com.liferay.portal.util.comparator.GroupNameComparator;
105 import com.liferay.portlet.exportimport.configuration.ExportImportConfigurationConstants;
106 import com.liferay.portlet.exportimport.configuration.ExportImportConfigurationSettingsMapFactory;
107 import com.liferay.portlet.exportimport.lar.PortletDataContext;
108 import com.liferay.portlet.exportimport.lar.PortletDataContextFactoryUtil;
109 import com.liferay.portlet.exportimport.lar.PortletDataHandler;
110 import com.liferay.portlet.exportimport.lar.PortletDataHandlerKeys;
111 import com.liferay.portlet.exportimport.model.ExportImportConfiguration;
112 import com.liferay.portlet.exportimport.staging.StagingConstants;
113 import com.liferay.portlet.exportimport.staging.StagingUtil;
114 import com.liferay.util.dao.orm.CustomSQLUtil;
115
116 import java.io.File;
117 import java.io.Serializable;
118
119 import java.util.ArrayList;
120 import java.util.Arrays;
121 import java.util.Collection;
122 import java.util.Collections;
123 import java.util.HashMap;
124 import java.util.HashSet;
125 import java.util.Iterator;
126 import java.util.LinkedHashMap;
127 import java.util.List;
128 import java.util.Locale;
129 import java.util.Map;
130 import java.util.Set;
131
132
205 public class GroupLocalServiceImpl extends GroupLocalServiceBaseImpl {
206
207 public static final String ORGANIZATION_NAME_SUFFIX = " LFR_ORGANIZATION";
208
209 public static final String ORGANIZATION_STAGING_SUFFIX = " (Staging)";
210
211
214 public GroupLocalServiceImpl() {
215 initImportLARFile();
216 }
217
218 @Override
219 public Group addGroup(
220 long userId, long parentGroupId, String className, long classPK,
221 long liveGroupId, Map<Locale, String> nameMap,
222 Map<Locale, String> descriptionMap, int type,
223 boolean manualMembership, int membershipRestriction,
224 String friendlyURL, boolean site, boolean inheritContent,
225 boolean active, ServiceContext serviceContext)
226 throws PortalException {
227
228
229
230 User user = userPersistence.findByPrimaryKey(userId);
231 className = GetterUtil.getString(className);
232 long classNameId = classNameLocalService.getClassNameId(className);
233
234 String groupKey = StringPool.BLANK;
235 String friendlyName = StringPool.BLANK;
236
237 if (nameMap != null) {
238 groupKey = nameMap.get(LocaleUtil.getDefault());
239 friendlyName = nameMap.get(LocaleUtil.getDefault());
240 }
241
242 long groupId = 0;
243
244 while (true) {
245 groupId = counterLocalService.increment();
246
247 User screenNameUser = userPersistence.fetchByC_SN(
248 user.getCompanyId(), String.valueOf(groupId));
249
250 if (screenNameUser == null) {
251 break;
252 }
253 }
254
255 boolean staging = isStaging(serviceContext);
256
257 long groupClassNameId = classNameLocalService.getClassNameId(
258 Group.class);
259
260 if ((classNameId <= 0) || className.equals(Group.class.getName()) ||
261 (className.equals(Company.class.getName()) && staging)) {
262
263 className = Group.class.getName();
264 classNameId = groupClassNameId;
265 classPK = groupId;
266 }
267 else if (className.equals(Organization.class.getName())) {
268 groupKey = getOrgGroupName(groupKey);
269 }
270 else if (!GroupConstants.USER_PERSONAL_SITE.equals(groupKey)) {
271 groupKey = String.valueOf(classPK);
272 }
273
274 if (className.equals(Organization.class.getName()) && staging) {
275 classPK = liveGroupId;
276 }
277
278 if (className.equals(Layout.class.getName())) {
279 Layout layout = layoutLocalService.getLayout(classPK);
280
281 parentGroupId = layout.getGroupId();
282 }
283
284 friendlyURL = getFriendlyURL(
285 user.getCompanyId(), groupId, classNameId, classPK, friendlyName,
286 friendlyURL);
287
288 if (staging) {
289 groupKey = groupKey.concat("-staging");
290
291 for (Locale locale : nameMap.keySet()) {
292 String name = nameMap.get(locale);
293
294 if (Validator.isNull(name)) {
295 continue;
296 }
297
298 nameMap.put(locale, name.concat(ORGANIZATION_STAGING_SUFFIX));
299 }
300
301 friendlyURL = getFriendlyURL(friendlyURL.concat("-staging"));
302 }
303
304 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
305 membershipRestriction =
306 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION;
307 }
308
309 if (className.equals(Group.class.getName())) {
310 if (!site && (liveGroupId == 0) &&
311 !groupKey.equals(GroupConstants.CONTROL_PANEL) &&
312 !groupKey.equals(GroupConstants.USER_PERSONAL_PANEL)) {
313
314 throw new IllegalArgumentException();
315 }
316 }
317 else if (!className.equals(Company.class.getName()) &&
318 !className.equals(Organization.class.getName()) &&
319 className.startsWith("com.liferay.portal.model.")) {
320
321 if (site) {
322 throw new IllegalArgumentException();
323 }
324 }
325
326 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
327 validateGroupKey(groupId, user.getCompanyId(), groupKey, site);
328 }
329
330 validateInheritContent(parentGroupId, inheritContent);
331
332 validateFriendlyURL(
333 user.getCompanyId(), groupId, classNameId, classPK, friendlyURL);
334
335 validateParentGroup(groupId, parentGroupId);
336
337 Group group = groupPersistence.create(groupId);
338
339 if (serviceContext != null) {
340 group.setUuid(serviceContext.getUuid());
341 }
342
343 group.setCompanyId(user.getCompanyId());
344 group.setCreatorUserId(userId);
345 group.setClassNameId(classNameId);
346 group.setClassPK(classPK);
347 group.setParentGroupId(parentGroupId);
348 group.setLiveGroupId(liveGroupId);
349 group.setTreePath(group.buildTreePath());
350 group.setGroupKey(groupKey);
351 group.setNameMap(nameMap);
352 group.setDescriptionMap(descriptionMap);
353 group.setType(type);
354 group.setManualMembership(manualMembership);
355 group.setMembershipRestriction(membershipRestriction);
356 group.setFriendlyURL(friendlyURL);
357 group.setInheritContent(inheritContent);
358 group.setSite(site);
359 group.setActive(active);
360
361 if ((serviceContext != null) && (classNameId == groupClassNameId) &&
362 !user.isDefaultUser()) {
363
364 group.setExpandoBridgeAttributes(serviceContext);
365 }
366
367 groupPersistence.update(group);
368
369
370
371 layoutSetLocalService.addLayoutSet(groupId, true);
372
373 layoutSetLocalService.addLayoutSet(groupId, false);
374
375
376
377 resourceLocalService.addResources(
378 group.getCompanyId(), 0, 0, Group.class.getName(),
379 group.getGroupId(), false, false, false);
380
381 if ((classNameId == groupClassNameId) && !user.isDefaultUser()) {
382
383
384
385 Role role = roleLocalService.getRole(
386 group.getCompanyId(), RoleConstants.SITE_OWNER);
387
388 userGroupRoleLocalService.addUserGroupRoles(
389 userId, groupId, new long[] {role.getRoleId()});
390
391
392
393 userLocalService.addGroupUsers(
394 group.getGroupId(), new long[] {userId});
395
396
397
398 if (serviceContext != null) {
399 updateAsset(
400 userId, group, serviceContext.getAssetCategoryIds(),
401 serviceContext.getAssetTagNames());
402 }
403 }
404
405 addPortletDefaultData(group);
406
407 return group;
408 }
409
410 @Override
411 public Group addGroup(
412 long userId, long parentGroupId, String className, long classPK,
413 long liveGroupId, Map<Locale, String> nameMap,
414 Map<Locale, String> descriptionMap, int type,
415 boolean manualMembership, int membershipRestriction,
416 String friendlyURL, boolean site, boolean active,
417 ServiceContext serviceContext)
418 throws PortalException {
419
420 return addGroup(
421 userId, parentGroupId, className, classPK, liveGroupId, nameMap,
422 descriptionMap, type, manualMembership, membershipRestriction,
423 friendlyURL, site, false, active, serviceContext);
424 }
425
426
459 @Deprecated
460 @Override
461 public Group addGroup(
462 long userId, long parentGroupId, String className, long classPK,
463 long liveGroupId, String name, String description, int type,
464 boolean manualMembership, int membershipRestriction,
465 String friendlyURL, boolean site, boolean active,
466 ServiceContext serviceContext)
467 throws PortalException {
468
469 return addGroup(
470 userId, parentGroupId, className, classPK, liveGroupId,
471 getLocalizationMap(name), getLocalizationMap(description), type,
472 manualMembership, membershipRestriction, friendlyURL, site, false,
473 active, serviceContext);
474 }
475
476
503 @Deprecated
504 @Override
505 public Group addGroup(
506 long userId, long parentGroupId, String className, long classPK,
507 String name, String description, int type, String friendlyURL,
508 boolean site, boolean active, ServiceContext serviceContext)
509 throws PortalException {
510
511 return addGroup(
512 userId, parentGroupId, className, classPK,
513 GroupConstants.DEFAULT_LIVE_GROUP_ID, getLocalizationMap(name),
514 getLocalizationMap(description), type, true,
515 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
516 active, serviceContext);
517 }
518
519
547 @Deprecated
548 @Override
549 public Group addGroup(
550 long userId, String className, long classPK, long liveGroupId,
551 String name, String description, int type, String friendlyURL,
552 boolean site, boolean active, ServiceContext serviceContext)
553 throws PortalException {
554
555 return addGroup(
556 userId, GroupConstants.DEFAULT_PARENT_GROUP_ID, className, classPK,
557 liveGroupId, getLocalizationMap(name),
558 getLocalizationMap(description), type, true,
559 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
560 active, serviceContext);
561 }
562
563
589 @Deprecated
590 @Override
591 public Group addGroup(
592 long userId, String className, long classPK, String name,
593 String description, int type, String friendlyURL, boolean site,
594 boolean active, ServiceContext serviceContext)
595 throws PortalException {
596
597 return addGroup(
598 userId, GroupConstants.DEFAULT_PARENT_GROUP_ID, className, classPK,
599 GroupConstants.DEFAULT_LIVE_GROUP_ID, getLocalizationMap(name),
600 getLocalizationMap(description), type, true,
601 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL, site,
602 active, serviceContext);
603 }
604
605
611 @Override
612 public void addRoleGroups(long roleId, long[] groupIds) {
613 rolePersistence.addGroups(roleId, groupIds);
614
615 PermissionCacheUtil.clearCache();
616 }
617
618
624 @Override
625 public void addUserGroups(long userId, long[] groupIds) {
626 userPersistence.addGroups(userId, groupIds);
627
628 PermissionCacheUtil.clearCache(userId);
629 }
630
631
641 @Override
642 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
643 public void checkCompanyGroup(long companyId) throws PortalException {
644 long classNameId = classNameLocalService.getClassNameId(Company.class);
645
646 int count = groupPersistence.countByC_C_C(
647 companyId, classNameId, companyId);
648
649 if (count == 0) {
650 long defaultUserId = userLocalService.getDefaultUserId(companyId);
651
652 groupLocalService.addGroup(
653 defaultUserId, GroupConstants.DEFAULT_PARENT_GROUP_ID,
654 Company.class.getName(), companyId,
655 GroupConstants.DEFAULT_LIVE_GROUP_ID,
656 getLocalizationMap(GroupConstants.GLOBAL), null, 0, true,
657 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION,
658 GroupConstants.GLOBAL_FRIENDLY_URL, true, true, null);
659 }
660 }
661
662
670 @Override
671 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
672 public void checkSystemGroups(long companyId) throws PortalException {
673 String companyIdHexString = StringUtil.toHexString(companyId);
674
675 for (Group group : groupFinder.findBySystem(companyId)) {
676 _systemGroupsMap.put(
677 companyIdHexString.concat(group.getGroupKey()), group);
678 }
679
680 long defaultUserId = userLocalService.getDefaultUserId(companyId);
681
682 String[] systemGroups = PortalUtil.getSystemGroups();
683
684 for (String groupKey : systemGroups) {
685 String groupCacheKey = companyIdHexString.concat(groupKey);
686
687 Group group = _systemGroupsMap.get(groupCacheKey);
688
689 if (group == null) {
690 group = groupPersistence.fetchByC_GK(companyId, groupKey);
691 }
692
693 if (group == null) {
694 String className = null;
695 long classPK = 0;
696 int type = GroupConstants.TYPE_SITE_OPEN;
697 String friendlyURL = null;
698 boolean site = true;
699
700 if (groupKey.equals(GroupConstants.CONTROL_PANEL)) {
701 type = GroupConstants.TYPE_SITE_PRIVATE;
702 friendlyURL = GroupConstants.CONTROL_PANEL_FRIENDLY_URL;
703 site = false;
704 }
705 else if (groupKey.equals(GroupConstants.GUEST)) {
706 friendlyURL = "/guest";
707 }
708 else if (groupKey.equals(GroupConstants.USER_PERSONAL_SITE)) {
709 className = UserPersonalSite.class.getName();
710 classPK = defaultUserId;
711 type = GroupConstants.TYPE_SITE_PRIVATE;
712 friendlyURL =
713 GroupConstants.USER_PERSONAL_SITE_FRIENDLY_URL;
714 site = false;
715 }
716 else if (groupKey.equals(GroupConstants.USER_PERSONAL_PANEL)) {
717 type = GroupConstants.TYPE_SITE_PRIVATE;
718 friendlyURL =
719 GroupConstants.USER_PERSONAL_PANEL_FRIENDLY_URL;
720 site = false;
721 }
722
723 group = groupLocalService.addGroup(
724 defaultUserId, GroupConstants.DEFAULT_PARENT_GROUP_ID,
725 className, classPK, GroupConstants.DEFAULT_LIVE_GROUP_ID,
726 getLocalizationMap(groupKey), null, type, true,
727 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, friendlyURL,
728 site, true, null);
729
730 if (groupKey.equals(GroupConstants.USER_PERSONAL_SITE)) {
731 initUserPersonalSitePermissions(group);
732 }
733 }
734
735 if (group.isControlPanel()) {
736 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
737 group.getGroupId(), true);
738
739 if (layoutSet.getPageCount() == 0) {
740 addControlPanelLayouts(group);
741 }
742 }
743
744 if (group.isGuest()) {
745 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
746 group.getGroupId(), false);
747
748 if (layoutSet.getPageCount() == 0) {
749 addDefaultGuestPublicLayouts(group);
750 }
751 }
752
753 if (group.isUserPersonalPanel()) {
754 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
755 group.getGroupId(), true);
756
757 if (layoutSet.getPageCount() == 0) {
758 addUserPersonalPanelLayouts(group);
759 }
760 }
761
762 _systemGroupsMap.put(groupCacheKey, group);
763 }
764 }
765
766
782 @Override
783 public Group deleteGroup(Group group) throws PortalException {
784 boolean deleteInProcess = GroupThreadLocal.isDeleteInProcess();
785
786 try {
787 GroupThreadLocal.setDeleteInProcess(true);
788
789 if (((group.isCompany() && !group.isCompanyStagingGroup()) ||
790 PortalUtil.isSystemGroup(group.getGroupKey())) &&
791 !CompanyThreadLocal.isDeleteInProcess()) {
792
793 throw new RequiredGroupException.MustNotDeleteSystemGroup(
794 group.getGroupId());
795 }
796
797 if (groupPersistence.countByC_P_S(
798 group.getCompanyId(), group.getGroupId(), true) > 0) {
799
800 throw new RequiredGroupException.MustNotDeleteGroupThatHasChild(
801 group.getGroupId());
802 }
803
804 List<BackgroundTask> backgroundTasks =
805 backgroundTaskLocalService.getBackgroundTasks(
806 group.getGroupId(),
807 BackgroundTaskConstants.STATUS_IN_PROGRESS);
808
809 if (!backgroundTasks.isEmpty()) {
810 throw new PendingBackgroundTaskException(
811 "Unable to delete group with pending background tasks");
812 }
813
814
815
816 backgroundTaskLocalService.deleteGroupBackgroundTasks(
817 group.getGroupId());
818
819
820
821 layoutSetBranchLocalService.deleteLayoutSetBranches(
822 group.getGroupId(), true, true);
823
824 layoutSetBranchLocalService.deleteLayoutSetBranches(
825 group.getGroupId(), false, true);
826
827
828
829 ServiceContext serviceContext = new ServiceContext();
830
831 try {
832 layoutSetLocalService.deleteLayoutSet(
833 group.getGroupId(), true, serviceContext);
834 }
835 catch (NoSuchLayoutSetException nslse) {
836 }
837
838 try {
839 layoutSetLocalService.deleteLayoutSet(
840 group.getGroupId(), false, serviceContext);
841 }
842 catch (NoSuchLayoutSetException nslse) {
843 }
844
845
846
847 userGroupRoleLocalService.deleteUserGroupRolesByGroupId(
848 group.getGroupId());
849
850
851
852 userGroupGroupRoleLocalService.deleteUserGroupGroupRolesByGroupId(
853 group.getGroupId());
854
855
856
857 membershipRequestLocalService.deleteMembershipRequests(
858 group.getGroupId());
859
860
861
862 portletPreferencesLocalService.deletePortletPreferences(
863 group.getGroupId(), PortletKeys.PREFS_OWNER_TYPE_GROUP,
864 PortletKeys.PREFS_PLID_SHARED);
865
866
867
868 dlAppLocalService.deleteAllRepositories(group.getGroupId());
869
870
871
872 teamLocalService.deleteTeams(group.getGroupId());
873
874
875
876 exportImportConfigurationLocalService.
877 deleteExportImportConfigurations(group.getGroupId());
878
879 unscheduleStaging(group);
880
881 if (group.hasStagingGroup()) {
882 try {
883 stagingLocalService.disableStaging(group, serviceContext);
884 }
885 catch (Exception e) {
886 _log.error(
887 "Unable to disable staging for group " +
888 group.getGroupId());
889 }
890 }
891
892
893
894 ThemeLoader themeLoader =
895 ThemeLoaderFactory.getDefaultThemeLoader();
896
897 if (themeLoader != null) {
898 String themePath =
899 themeLoader.getFileStorage() + StringPool.SLASH +
900 group.getGroupId();
901
902 FileUtil.deltree(themePath + "-private");
903 FileUtil.deltree(themePath + "-public");
904 }
905
906
907
908 deletePortletData(group);
909
910
911
912 if (group.isRegularSite()) {
913 assetEntryLocalService.deleteEntry(
914 Group.class.getName(), group.getGroupId());
915 }
916
917 assetEntryLocalService.deleteGroupEntries(group.getGroupId());
918
919 assetTagLocalService.deleteGroupTags(group.getGroupId());
920
921 assetVocabularyLocalService.deleteVocabularies(group.getGroupId());
922
923
924
925 expandoRowLocalService.deleteRows(group.getGroupId());
926
927
928
929 shoppingCartLocalService.deleteGroupCarts(group.getGroupId());
930 shoppingCategoryLocalService.deleteCategories(group.getGroupId());
931 shoppingCouponLocalService.deleteCoupons(group.getGroupId());
932 shoppingOrderLocalService.deleteOrders(group.getGroupId());
933
934
935
936 socialActivityLocalService.deleteActivities(group.getGroupId());
937 socialActivitySettingLocalService.deleteActivitySettings(
938 group.getGroupId());
939 socialRequestLocalService.deleteRequests(
940 classNameLocalService.getClassNameId(Group.class),
941 group.getGroupId());
942
943
944
945 scFrameworkVersionLocalService.deleteFrameworkVersions(
946 group.getGroupId());
947 scProductEntryLocalService.deleteProductEntries(group.getGroupId());
948
949
950
951 List<ResourcePermission> resourcePermissions =
952 resourcePermissionPersistence.findByC_LikeP(
953 group.getCompanyId(), String.valueOf(group.getGroupId()));
954
955 for (ResourcePermission resourcePermission : resourcePermissions) {
956 resourcePermissionLocalService.deleteResourcePermission(
957 resourcePermission);
958 }
959
960 if (!group.isStagingGroup() &&
961 (group.isOrganization() || group.isRegularSite())) {
962
963 resourceLocalService.deleteResource(
964 group.getCompanyId(), Group.class.getName(),
965 ResourceConstants.SCOPE_INDIVIDUAL, group.getGroupId());
966 }
967
968
969
970 trashEntryLocalService.deleteEntries(group.getGroupId());
971
972
973
974 List<WorkflowHandler<?>> scopeableWorkflowHandlers =
975 WorkflowHandlerRegistryUtil.getScopeableWorkflowHandlers();
976
977 for (WorkflowHandler<?> scopeableWorkflowHandler :
978 scopeableWorkflowHandlers) {
979
980 if (!scopeableWorkflowHandler.isVisible()) {
981 continue;
982 }
983
984 WorkflowDefinitionLink workflowDefinitionLink =
985 workflowDefinitionLinkLocalService.
986 fetchWorkflowDefinitionLink(
987 group.getCompanyId(), group.getGroupId(),
988 scopeableWorkflowHandler.getClassName(), 0, 0,
989 true);
990
991 if (workflowDefinitionLink == null) {
992 continue;
993 }
994
995 workflowDefinitionLinkLocalService.deleteWorkflowDefinitionLink(
996 workflowDefinitionLink);
997 }
998
999
1000
1001 if (!group.isStagingGroup() && group.isOrganization() &&
1002 group.isSite()) {
1003
1004 group.setSite(false);
1005
1006 groupPersistence.update(group);
1007 }
1008 else {
1009 groupPersistence.remove(group);
1010 }
1011
1012
1013
1014 PermissionCacheUtil.clearCache();
1015
1016 return group;
1017 }
1018 finally {
1019 GroupThreadLocal.setDeleteInProcess(deleteInProcess);
1020 }
1021 }
1022
1023
1039 @Override
1040 public Group deleteGroup(long groupId) throws PortalException {
1041 Group group = groupPersistence.findByPrimaryKey(groupId);
1042
1043 return deleteGroup(group);
1044 }
1045
1046 @Override
1047 public synchronized void disableStaging(long groupId)
1048 throws PortalException {
1049
1050 Group group = groupPersistence.findByPrimaryKey(groupId);
1051
1052 int stagingGroupCount = group.getRemoteStagingGroupCount();
1053
1054 if (stagingGroupCount > 0) {
1055 stagingGroupCount = stagingGroupCount - 1;
1056
1057 group.setRemoteStagingGroupCount(stagingGroupCount);
1058
1059 if (stagingGroupCount == 0) {
1060 UnicodeProperties typeSettingsProperties =
1061 group.getTypeSettingsProperties();
1062
1063 List<String> keys = new ArrayList<>();
1064
1065 for (String key : typeSettingsProperties.keySet()) {
1066 if (key.startsWith(StagingConstants.STAGED_PORTLET)) {
1067 keys.add(key);
1068 }
1069 }
1070
1071 for (String key : keys) {
1072 typeSettingsProperties.remove(key);
1073 }
1074
1075 group.setTypeSettingsProperties(typeSettingsProperties);
1076 }
1077
1078 groupPersistence.update(group);
1079 }
1080 }
1081
1082 @Override
1083 public synchronized void enableStaging(long groupId)
1084 throws PortalException {
1085
1086 Group group = groupPersistence.findByPrimaryKey(groupId);
1087
1088 int stagingGroupCount = group.getRemoteStagingGroupCount() + 1;
1089
1090 group.setRemoteStagingGroupCount(stagingGroupCount);
1091
1092 groupPersistence.update(group);
1093 }
1094
1095
1102 @Override
1103 public Group fetchCompanyGroup(long companyId) {
1104 long classNameId = classNameLocalService.getClassNameId(Company.class);
1105
1106 return groupPersistence.fetchByC_C_C(companyId, classNameId, companyId);
1107 }
1108
1109
1117 @Override
1118 public Group fetchFriendlyURLGroup(long companyId, String friendlyURL) {
1119 if (Validator.isNull(friendlyURL)) {
1120 return null;
1121 }
1122
1123 friendlyURL = getFriendlyURL(friendlyURL);
1124
1125 return groupPersistence.fetchByC_F(companyId, friendlyURL);
1126 }
1127
1128
1137 @Override
1138 @Skip
1139 public Group fetchGroup(long companyId, String groupKey) {
1140 Group group = _systemGroupsMap.get(
1141 StringUtil.toHexString(companyId).concat(groupKey));
1142
1143 if (group != null) {
1144 return group;
1145 }
1146
1147 return groupLocalService.loadFetchGroup(companyId, groupKey);
1148 }
1149
1150 @Override
1151 public Group fetchUserGroup(long companyId, long userId) {
1152 long classNameId = classNameLocalService.getClassNameId(User.class);
1153
1154 return groupPersistence.fetchByC_C_C(companyId, classNameId, userId);
1155 }
1156
1157
1166 @Override
1167 public Group fetchUserPersonalSiteGroup(long companyId)
1168 throws PortalException {
1169
1170 long classNameId = classNameLocalService.getClassNameId(
1171 UserPersonalSite.class);
1172 long defaultUserId = userLocalService.getDefaultUserId(companyId);
1173
1174 return groupPersistence.fetchByC_C_C(
1175 companyId, classNameId, defaultUserId);
1176 }
1177
1178
1185 @Override
1186 public Group getCompanyGroup(long companyId) throws PortalException {
1187 long classNameId = classNameLocalService.getClassNameId(Company.class);
1188
1189 return groupPersistence.findByC_C_C(companyId, classNameId, companyId);
1190 }
1191
1192
1211 @Override
1212 public List<Group> getCompanyGroups(long companyId, int start, int end) {
1213 return groupPersistence.findByCompanyId(companyId, start, end);
1214 }
1215
1216
1222 @Override
1223 public int getCompanyGroupsCount(long companyId) {
1224 return groupPersistence.countByCompanyId(companyId);
1225 }
1226
1227
1236 @Override
1237 public Group getFriendlyURLGroup(long companyId, String friendlyURL)
1238 throws PortalException {
1239
1240 if (Validator.isNull(friendlyURL)) {
1241 StringBundler sb = new StringBundler(5);
1242
1243 sb.append("{companyId=");
1244 sb.append(companyId);
1245 sb.append(", friendlyURL=");
1246 sb.append(friendlyURL);
1247 sb.append("}");
1248
1249 throw new NoSuchGroupException(sb.toString());
1250 }
1251
1252 friendlyURL = getFriendlyURL(friendlyURL);
1253
1254 return groupPersistence.findByC_F(companyId, friendlyURL);
1255 }
1256
1257
1265 @Override
1266 @ThreadLocalCachable
1267 public Group getGroup(long groupId) throws PortalException {
1268 return groupPersistence.findByPrimaryKey(groupId);
1269 }
1270
1271
1279 @Override
1280 @Skip
1281 public Group getGroup(long companyId, String groupKey)
1282 throws PortalException {
1283
1284 Group group = _systemGroupsMap.get(
1285 StringUtil.toHexString(companyId).concat(groupKey));
1286
1287 if (group != null) {
1288 return group;
1289 }
1290
1291 return groupLocalService.loadGetGroup(companyId, groupKey);
1292 }
1293
1294
1298 @Deprecated
1299 @Override
1300 public String getGroupDescriptiveName(Group group, Locale locale)
1301 throws PortalException {
1302
1303 return group.getDescriptiveName(locale);
1304 }
1305
1306
1310 @Deprecated
1311 @Override
1312 public String getGroupDescriptiveName(long groupId, Locale locale)
1313 throws PortalException {
1314
1315 Group group = groupPersistence.findByPrimaryKey(groupId);
1316
1317 return group.getDescriptiveName(locale);
1318 }
1319
1320
1329 @Override
1330 public List<Group> getGroups(
1331 long companyId, long parentGroupId, boolean site) {
1332
1333 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
1334 return groupPersistence.findByC_S(companyId, site);
1335 }
1336
1337 return groupPersistence.findByC_P_S(companyId, parentGroupId, site);
1338 }
1339
1340 @Override
1341 public List<Group> getGroups(
1342 long companyId, long parentGroupId, boolean site,
1343 boolean inheritContent) {
1344
1345 return groupPersistence.findByC_P_S_I(
1346 companyId, parentGroupId, site, inheritContent);
1347 }
1348
1349
1359 @Override
1360 public List<Group> getGroups(
1361 long companyId, String className, long parentGroupId) {
1362
1363 long classNameId = classNameLocalService.getClassNameId(className);
1364
1365 return groupPersistence.findByC_C_P(
1366 companyId, classNameId, parentGroupId);
1367 }
1368
1369
1380 @Override
1381 public List<Group> getGroups(
1382 long companyId, String className, long parentGroupId, int start,
1383 int end) {
1384
1385 long classNameId = classNameLocalService.getClassNameId(className);
1386
1387 return groupPersistence.findByC_C_P(
1388 companyId, classNameId, parentGroupId, start, end);
1389 }
1390
1391
1398 @Override
1399 public List<Group> getGroups(long[] groupIds) throws PortalException {
1400 List<Group> groups = new ArrayList<>(groupIds.length);
1401
1402 for (long groupId : groupIds) {
1403 Group group = getGroup(groupId);
1404
1405 groups.add(group);
1406 }
1407
1408 return groups;
1409 }
1410
1411
1420 @Override
1421 public int getGroupsCount(
1422 long companyId, long parentGroupId, boolean site) {
1423
1424 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
1425 return groupPersistence.countByC_S(companyId, site);
1426 }
1427
1428 return groupPersistence.countByC_P_S(companyId, parentGroupId, site);
1429 }
1430
1431
1440 @Override
1441 public int getGroupsCount(
1442 long companyId, String className, long parentGroupId) {
1443
1444 long classNameId = classNameLocalService.getClassNameId(className);
1445
1446 return groupPersistence.countByC_C_P(
1447 companyId, classNameId, parentGroupId);
1448 }
1449
1450
1458 @Override
1459 public Group getLayoutGroup(long companyId, long plid)
1460 throws PortalException {
1461
1462 long classNameId = classNameLocalService.getClassNameId(Layout.class);
1463
1464 return groupPersistence.findByC_C_C(companyId, classNameId, plid);
1465 }
1466
1467
1475 @Override
1476 public Group getLayoutPrototypeGroup(long companyId, long layoutPrototypeId)
1477 throws PortalException {
1478
1479 long classNameId = classNameLocalService.getClassNameId(
1480 LayoutPrototype.class);
1481
1482 return groupPersistence.findByC_C_C(
1483 companyId, classNameId, layoutPrototypeId);
1484 }
1485
1486
1494 @Override
1495 public Group getLayoutSetPrototypeGroup(
1496 long companyId, long layoutSetPrototypeId)
1497 throws PortalException {
1498
1499 long classNameId = classNameLocalService.getClassNameId(
1500 LayoutSetPrototype.class);
1501
1502 return groupPersistence.findByC_C_C(
1503 companyId, classNameId, layoutSetPrototypeId);
1504 }
1505
1506
1530 @Deprecated
1531 @Override
1532 public List<Group> getLayoutsGroups(
1533 long companyId, long parentGroupId, boolean site, int start, int end) {
1534
1535 return getLayoutsGroups(
1536 companyId, parentGroupId, site, start, end, null);
1537 }
1538
1539
1564 @Override
1565 public List<Group> getLayoutsGroups(
1566 long companyId, long parentGroupId, boolean site, int start, int end,
1567 OrderByComparator<Group> obc) {
1568
1569 return groupFinder.findByLayouts(
1570 companyId, parentGroupId, site, start, end, obc);
1571 }
1572
1573
1582 @Override
1583 public int getLayoutsGroupsCount(
1584 long companyId, long parentGroupId, boolean site) {
1585
1586 return groupFinder.countByLayouts(companyId, parentGroupId, site);
1587 }
1588
1589
1594 @Override
1595 public List<Group> getLiveGroups() {
1596 return groupFinder.findByLiveGroups();
1597 }
1598
1599
1621 @Override
1622 public List<Group> getNoLayoutsGroups(
1623 String className, boolean privateLayout, int start, int end) {
1624
1625 long classNameId = classNameLocalService.getClassNameId(className);
1626
1627 return groupFinder.findByNoLayouts(
1628 classNameId, privateLayout, start, end);
1629 }
1630
1631
1638 @Override
1639 public List<Group> getNullFriendlyURLGroups() {
1640 return groupFinder.findByNullFriendlyURL();
1641 }
1642
1643
1651 @Override
1652 public Group getOrganizationGroup(long companyId, long organizationId)
1653 throws PortalException {
1654
1655 long classNameId = classNameLocalService.getClassNameId(
1656 Organization.class);
1657
1658 return groupPersistence.findByC_C_C(
1659 companyId, classNameId, organizationId);
1660 }
1661
1662
1668 @Override
1669 public List<Group> getOrganizationsGroups(
1670 List<Organization> organizations) {
1671
1672 List<Group> organizationGroups = new ArrayList<>();
1673
1674 for (int i = 0; i < organizations.size(); i++) {
1675 Organization organization = organizations.get(i);
1676
1677 Group group = organization.getGroup();
1678
1679 organizationGroups.add(group);
1680 }
1681
1682 return organizationGroups;
1683 }
1684
1685
1691 @Override
1692 public List<Group> getOrganizationsRelatedGroups(
1693 List<Organization> organizations) {
1694
1695 List<Group> organizationGroups = new ArrayList<>();
1696
1697 for (int i = 0; i < organizations.size(); i++) {
1698 Organization organization = organizations.get(i);
1699
1700 List<Group> groups = organizationPersistence.getGroups(
1701 organization.getOrganizationId());
1702
1703 organizationGroups.addAll(groups);
1704 }
1705
1706 return organizationGroups;
1707 }
1708
1709
1719 @Override
1720 public List<Group> getParentGroups(long groupId) throws PortalException {
1721 if (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
1722 return new ArrayList<>();
1723 }
1724
1725 Group group = groupPersistence.findByPrimaryKey(groupId);
1726
1727 return group.getAncestors();
1728 }
1729
1730
1737 @Override
1738 public Group getStagingGroup(long liveGroupId) throws PortalException {
1739 return groupPersistence.findByLiveGroupId(liveGroupId);
1740 }
1741
1742
1750 @Override
1751 public Group getUserGroup(long companyId, long userId)
1752 throws PortalException {
1753
1754 long classNameId = classNameLocalService.getClassNameId(User.class);
1755
1756 return groupPersistence.findByC_C_C(companyId, classNameId, userId);
1757 }
1758
1759
1768 @Override
1769 public Group getUserGroupGroup(long companyId, long userGroupId)
1770 throws PortalException {
1771
1772 long classNameId = classNameLocalService.getClassNameId(
1773 UserGroup.class);
1774
1775 return groupPersistence.findByC_C_C(
1776 companyId, classNameId, userGroupId);
1777 }
1778
1779
1790 @Override
1791 public List<Group> getUserGroups(long userId, boolean inherit)
1792 throws PortalException {
1793
1794 return getUserGroups(
1795 userId, inherit, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1796 }
1797
1798
1824 @Override
1825 public List<Group> getUserGroups(
1826 long userId, boolean inherit, int start, int end)
1827 throws PortalException {
1828
1829 if (inherit) {
1830 User user = userPersistence.findByPrimaryKey(userId);
1831
1832 LinkedHashMap<String, Object> groupParams = new LinkedHashMap<>();
1833
1834 groupParams.put("usersGroups", new Long(userId));
1835
1836 return search(
1837 user.getCompanyId(), null, null, groupParams, start, end);
1838 }
1839 else {
1840 return userPersistence.getGroups(userId, start, end);
1841 }
1842 }
1843
1844
1852 @Override
1853 public List<Group> getUserGroupsGroups(List<UserGroup> userGroups)
1854 throws PortalException {
1855
1856 List<Group> userGroupGroups = new ArrayList<>();
1857
1858 for (int i = 0; i < userGroups.size(); i++) {
1859 UserGroup userGroup = userGroups.get(i);
1860
1861 Group group = userGroup.getGroup();
1862
1863 userGroupGroups.add(group);
1864 }
1865
1866 return userGroupGroups;
1867 }
1868
1869
1875 @Override
1876 public List<Group> getUserGroupsRelatedGroups(List<UserGroup> userGroups) {
1877 List<Group> userGroupGroups = new ArrayList<>();
1878
1879 for (int i = 0; i < userGroups.size(); i++) {
1880 UserGroup userGroup = userGroups.get(i);
1881
1882 List<Group> groups = userGroupPersistence.getGroups(
1883 userGroup.getUserGroupId());
1884
1885 userGroupGroups.addAll(groups);
1886 }
1887
1888 return userGroupGroups;
1889 }
1890
1891
1916 @Override
1917 public List<Group> getUserOrganizationsGroups(
1918 long userId, int start, int end)
1919 throws PortalException {
1920
1921 List<Group> userOrgsGroups = new ArrayList<>();
1922
1923 List<Organization> userOrgs =
1924 organizationLocalService.getUserOrganizations(userId, start, end);
1925
1926 for (Organization organization : userOrgs) {
1927 userOrgsGroups.add(0, organization.getGroup());
1928
1929 if (!PropsValues.ORGANIZATIONS_MEMBERSHIP_STRICT) {
1930 for (Organization ancestorOrganization :
1931 organization.getAncestors()) {
1932
1933 userOrgsGroups.add(0, ancestorOrganization.getGroup());
1934 }
1935 }
1936 }
1937
1938 return ListUtil.unique(userOrgsGroups);
1939 }
1940
1941
1949 @Override
1950 public Group getUserPersonalSiteGroup(long companyId)
1951 throws PortalException {
1952
1953 long classNameId = classNameLocalService.getClassNameId(
1954 UserPersonalSite.class);
1955 long defaultUserId = userLocalService.getDefaultUserId(companyId);
1956
1957 return groupPersistence.findByC_C_C(
1958 companyId, classNameId, defaultUserId);
1959 }
1960
1961 @Override
1962 public List<Group> getUserSitesGroups(long userId) throws PortalException {
1963 User user = userPersistence.findByPrimaryKey(userId);
1964
1965 LinkedHashMap<String, Object> groupParams = new LinkedHashMap<>();
1966
1967 groupParams.put("inherit", Boolean.TRUE);
1968 groupParams.put("site", Boolean.TRUE);
1969 groupParams.put("usersGroups", userId);
1970
1971 return groupFinder.findByCompanyId(
1972 user.getCompanyId(), groupParams, QueryUtil.ALL_POS,
1973 QueryUtil.ALL_POS, new GroupNameComparator(true));
1974 }
1975
1976 @Override
1977 public List<Group> getUserSitesGroups(
1978 long userId, boolean includeAdministrative)
1979 throws PortalException {
1980
1981 if (!includeAdministrative) {
1982 return getUserSitesGroups(userId);
1983 }
1984
1985 Set<Group> sites = new HashSet<>();
1986
1987 List<UserGroupRole> userGroupRoles =
1988 userGroupRoleLocalService.getUserGroupRoles(userId);
1989
1990 for (UserGroupRole userGroupRole : userGroupRoles) {
1991 Role role = userGroupRole.getRole();
1992
1993 String roleName = role.getName();
1994
1995 if (roleName.equals(RoleConstants.SITE_ADMINISTRATOR) ||
1996 roleName.equals(RoleConstants.SITE_OWNER)) {
1997
1998 Group group = userGroupRole.getGroup();
1999
2000 sites.add(group);
2001 }
2002 }
2003
2004 sites.addAll(getUserSitesGroups(userId));
2005
2006 return new ArrayList<>(sites);
2007 }
2008
2009
2016 @Override
2017 public boolean hasStagingGroup(long liveGroupId) {
2018 if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
2019 return true;
2020 }
2021 else {
2022 return false;
2023 }
2024 }
2025
2026
2036 @Override
2037 public boolean hasUserGroup(long userId, long groupId) {
2038 return hasUserGroup(userId, groupId, true);
2039 }
2040
2041
2053 @Override
2054 public boolean hasUserGroup(long userId, long groupId, boolean inherit) {
2055 if (groupFinder.countByG_U(groupId, userId, inherit) > 0) {
2056 return true;
2057 }
2058 else {
2059 return false;
2060 }
2061 }
2062
2063
2072 @Override
2073 public Group loadFetchGroup(long companyId, String groupKey) {
2074 return groupPersistence.fetchByC_GK(companyId, groupKey);
2075 }
2076
2077
2085 @Override
2086 public Group loadGetGroup(long companyId, String groupKey)
2087 throws PortalException {
2088
2089 return groupPersistence.findByC_GK(companyId, groupKey);
2090 }
2091
2092
2105 @Override
2106 public void rebuildTree(long companyId) throws PortalException {
2107 TreePathUtil.rebuildTree(
2108 companyId, GroupConstants.DEFAULT_PARENT_GROUP_ID, StringPool.SLASH,
2109 new TreeModelTasksAdapter<Group>() {
2110
2111 @Override
2112 public List<Group> findTreeModels(
2113 long previousId, long companyId, long parentPrimaryKey,
2114 int size) {
2115
2116 return groupPersistence.findByG_C_P(
2117 previousId, companyId, parentPrimaryKey,
2118 QueryUtil.ALL_POS, size, new GroupIdComparator(true));
2119 }
2120
2121 }
2122 );
2123 }
2124
2125
2153 @Override
2154 public List<Group> search(
2155 long companyId, LinkedHashMap<String, Object> params, int start,
2156 int end) {
2157
2158 return groupFinder.findByCompanyId(
2159 companyId, params, start, end, new GroupNameComparator(true));
2160 }
2161
2162
2193 @Override
2194 public List<Group> search(
2195 long companyId, long parentGroupId, String keywords,
2196 LinkedHashMap<String, Object> params, int start, int end) {
2197
2198 return search(
2199 companyId, getClassNameIds(), parentGroupId, keywords, params,
2200 start, end, null);
2201 }
2202
2203
2236 @Override
2237 public List<Group> search(
2238 long companyId, long parentGroupId, String keywords,
2239 LinkedHashMap<String, Object> params, int start, int end,
2240 OrderByComparator<Group> obc) {
2241
2242 return search(
2243 companyId, getClassNameIds(), parentGroupId, keywords, params,
2244 start, end, obc);
2245 }
2246
2247
2281 @Override
2282 public List<Group> search(
2283 long companyId, long parentGroupId, String name, String description,
2284 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2285 int end) {
2286
2287 return search(
2288 companyId, getClassNameIds(), parentGroupId, name, description,
2289 params, andOperator, start, end, null);
2290 }
2291
2292
2328 @Override
2329 public List<Group> search(
2330 long companyId, long parentGroupId, String name, String description,
2331 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2332 int end, OrderByComparator<Group> obc) {
2333
2334 return search(
2335 companyId, getClassNameIds(), parentGroupId, name, description,
2336 params, andOperator, start, end, obc);
2337 }
2338
2339
2373 @Override
2374 public List<Group> search(
2375 long companyId, long[] classNameIds, long parentGroupId,
2376 String keywords, LinkedHashMap<String, Object> params, int start,
2377 int end) {
2378
2379 return search(
2380 companyId, classNameIds, parentGroupId, keywords, params, start,
2381 end, null);
2382 }
2383
2384
2420 @Override
2421 public List<Group> search(
2422 long companyId, long[] classNameIds, long parentGroupId,
2423 String keywords, LinkedHashMap<String, Object> params, int start,
2424 int end, OrderByComparator<Group> obc) {
2425
2426 String[] keywordsArray = getSearchNames(companyId, keywords);
2427
2428 boolean andOperator = false;
2429
2430 if (Validator.isNull(keywords)) {
2431 andOperator = true;
2432 }
2433
2434 if (isUseComplexSQL(classNameIds)) {
2435 return groupFinder.findByC_C_PG_N_D(
2436 companyId, classNameIds, parentGroupId, keywordsArray,
2437 keywordsArray, params, andOperator, start, end, obc);
2438 }
2439
2440 Collection<Group> groups = doSearch(
2441 companyId, classNameIds, parentGroupId, keywordsArray,
2442 keywordsArray, params, andOperator);
2443
2444 return sort(groups, start, end, obc);
2445 }
2446
2447
2484 @Override
2485 public List<Group> search(
2486 long companyId, long[] classNameIds, long parentGroupId, String name,
2487 String description, LinkedHashMap<String, Object> params,
2488 boolean andOperator, int start, int end) {
2489
2490 return search(
2491 companyId, classNameIds, parentGroupId, name, description, params,
2492 andOperator, start, end, null);
2493 }
2494
2495
2534 @Override
2535 public List<Group> search(
2536 long companyId, long[] classNameIds, long parentGroupId, String name,
2537 String description, LinkedHashMap<String, Object> params,
2538 boolean andOperator, int start, int end, OrderByComparator<Group> obc) {
2539
2540 String[] names = getSearchNames(companyId, name);
2541 String[] descriptions = CustomSQLUtil.keywords(description);
2542
2543 if (isUseComplexSQL(classNameIds)) {
2544 return groupFinder.findByC_C_PG_N_D(
2545 companyId, classNameIds, parentGroupId, names, descriptions,
2546 params, andOperator, start, end, obc);
2547 }
2548
2549 Collection<Group> groups = doSearch(
2550 companyId, classNameIds, parentGroupId, names, descriptions, params,
2551 andOperator);
2552
2553 return sort(groups, start, end, obc);
2554 }
2555
2556
2588 @Override
2589 public List<Group> search(
2590 long companyId, long[] classNameIds, String keywords,
2591 LinkedHashMap<String, Object> params, int start, int end) {
2592
2593 return search(
2594 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
2595 keywords, params, start, end, null);
2596 }
2597
2598
2632 @Override
2633 public List<Group> search(
2634 long companyId, long[] classNameIds, String keywords,
2635 LinkedHashMap<String, Object> params, int start, int end,
2636 OrderByComparator<Group> obc) {
2637
2638 return search(
2639 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
2640 keywords, params, start, end, obc);
2641 }
2642
2643
2679 @Override
2680 public List<Group> search(
2681 long companyId, long[] classNameIds, String name, String description,
2682 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2683 int end) {
2684
2685 return search(
2686 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
2687 description, params, andOperator, start, end, null);
2688 }
2689
2690
2728 @Override
2729 public List<Group> search(
2730 long companyId, long[] classNameIds, String name, String description,
2731 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2732 int end, OrderByComparator<Group> obc) {
2733
2734 return search(
2735 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
2736 description, params, andOperator, start, end, obc);
2737 }
2738
2739
2768 @Override
2769 @ThreadLocalCachable
2770 public List<Group> search(
2771 long companyId, String keywords, LinkedHashMap<String, Object> params,
2772 int start, int end) {
2773
2774 return search(
2775 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2776 keywords, params, start, end, null);
2777 }
2778
2779
2810 @Override
2811 public List<Group> search(
2812 long companyId, String keywords, LinkedHashMap<String, Object> params,
2813 int start, int end, OrderByComparator<Group> obc) {
2814
2815 return search(
2816 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2817 keywords, params, start, end, obc);
2818 }
2819
2820
2853 @Override
2854 public List<Group> search(
2855 long companyId, String name, String description,
2856 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2857 int end) {
2858
2859 return search(
2860 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2861 name, description, params, andOperator, start, end, null);
2862 }
2863
2864
2899 @Override
2900 public List<Group> search(
2901 long companyId, String name, String description,
2902 LinkedHashMap<String, Object> params, boolean andOperator, int start,
2903 int end, OrderByComparator<Group> obc) {
2904
2905 return search(
2906 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
2907 name, description, params, andOperator, start, end, obc);
2908 }
2909
2910
2927 @Override
2928 @ThreadLocalCachable
2929 public int searchCount(
2930 long companyId, long parentGroupId, String keywords,
2931 LinkedHashMap<String, Object> params) {
2932
2933 return searchCount(
2934 companyId, getClassNameIds(), parentGroupId, keywords, params);
2935 }
2936
2937
2958 @Override
2959 @ThreadLocalCachable
2960 public int searchCount(
2961 long companyId, long parentGroupId, String name, String description,
2962 LinkedHashMap<String, Object> params, boolean andOperator) {
2963
2964 return searchCount(
2965 companyId, getClassNameIds(), parentGroupId, name, description,
2966 params, andOperator);
2967 }
2968
2969
2989 @Override
2990 @ThreadLocalCachable
2991 public int searchCount(
2992 long companyId, long[] classNameIds, long parentGroupId,
2993 String keywords, LinkedHashMap<String, Object> params) {
2994
2995 String[] keywordsArray = getSearchNames(companyId, keywords);
2996
2997 boolean andOperator = false;
2998
2999 if (Validator.isNull(keywords)) {
3000 andOperator = true;
3001 }
3002
3003 if (isUseComplexSQL(classNameIds)) {
3004 return groupFinder.countByC_C_PG_N_D(
3005 companyId, classNameIds, parentGroupId, keywordsArray,
3006 keywordsArray, params, andOperator);
3007 }
3008
3009 Collection<Group> groups = doSearch(
3010 companyId, classNameIds, parentGroupId, keywordsArray,
3011 keywordsArray, params, andOperator);
3012
3013 return groups.size();
3014 }
3015
3016
3039 @Override
3040 @ThreadLocalCachable
3041 public int searchCount(
3042 long companyId, long[] classNameIds, long parentGroupId, String name,
3043 String description, LinkedHashMap<String, Object> params,
3044 boolean andOperator) {
3045
3046 String[] names = getSearchNames(companyId, name);
3047 String[] descriptions = CustomSQLUtil.keywords(description);
3048
3049 if (isUseComplexSQL(classNameIds)) {
3050 return groupFinder.countByC_C_PG_N_D(
3051 companyId, classNameIds, parentGroupId, names, descriptions,
3052 params, andOperator);
3053 }
3054
3055 Collection<Group> groups = doSearch(
3056 companyId, classNameIds, parentGroupId, names, descriptions, params,
3057 andOperator);
3058
3059 return groups.size();
3060 }
3061
3062
3080 @Override
3081 @ThreadLocalCachable
3082 public int searchCount(
3083 long companyId, long[] classNameIds, String keywords,
3084 LinkedHashMap<String, Object> params) {
3085
3086 return searchCount(
3087 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID,
3088 keywords, params);
3089 }
3090
3091
3112 @Override
3113 @ThreadLocalCachable
3114 public int searchCount(
3115 long companyId, long[] classNameIds, String name, String description,
3116 LinkedHashMap<String, Object> params, boolean andOperator) {
3117
3118 return searchCount(
3119 companyId, classNameIds, GroupConstants.ANY_PARENT_GROUP_ID, name,
3120 description, params, andOperator);
3121 }
3122
3123
3139 @Override
3140 @ThreadLocalCachable
3141 public int searchCount(
3142 long companyId, String keywords, LinkedHashMap<String, Object> params) {
3143
3144 return searchCount(
3145 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
3146 keywords, params);
3147 }
3148
3149
3169 @Override
3170 @ThreadLocalCachable
3171 public int searchCount(
3172 long companyId, String name, String description,
3173 LinkedHashMap<String, Object> params, boolean andOperator) {
3174
3175 return searchCount(
3176 companyId, getClassNameIds(), GroupConstants.ANY_PARENT_GROUP_ID,
3177 name, description, params, andOperator);
3178 }
3179
3180
3187 @Override
3188 public void setRoleGroups(long roleId, long[] groupIds) {
3189 rolePersistence.setGroups(roleId, groupIds);
3190
3191 PermissionCacheUtil.clearCache();
3192 }
3193
3194
3200 @Override
3201 public void unsetRoleGroups(long roleId, long[] groupIds) {
3202 rolePersistence.removeGroups(roleId, groupIds);
3203
3204 PermissionCacheUtil.clearCache();
3205 }
3206
3207
3213 @Override
3214 public void unsetUserGroups(long userId, long[] groupIds) {
3215 userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
3216
3217 userPersistence.removeGroups(userId, groupIds);
3218
3219 PermissionCacheUtil.clearCache(userId);
3220 }
3221
3222
3232 @Override
3233 public void updateAsset(
3234 long userId, Group group, long[] assetCategoryIds,
3235 String[] assetTagNames)
3236 throws PortalException {
3237
3238 User user = userPersistence.findByPrimaryKey(userId);
3239
3240 Company company = companyPersistence.findByPrimaryKey(
3241 user.getCompanyId());
3242
3243 Group companyGroup = company.getGroup();
3244
3245 assetEntryLocalService.updateEntry(
3246 userId, companyGroup.getGroupId(), null, null,
3247 Group.class.getName(), group.getGroupId(), null, 0,
3248 assetCategoryIds, assetTagNames, false, null, null, null, null,
3249 group.getDescriptiveName(), group.getDescription(), null, null,
3250 null, 0, 0, null);
3251 }
3252
3253
3264 @Override
3265 public Group updateFriendlyURL(long groupId, String friendlyURL)
3266 throws PortalException {
3267
3268 Group group = groupPersistence.findByPrimaryKey(groupId);
3269
3270 if (group.isUser()) {
3271 User user = userPersistence.findByPrimaryKey(group.getClassPK());
3272
3273 friendlyURL = StringPool.SLASH + user.getScreenName();
3274
3275 if (group.getFriendlyURL().equals(friendlyURL)) {
3276 return group;
3277 }
3278 }
3279
3280 friendlyURL = getFriendlyURL(
3281 group.getCompanyId(), groupId, group.getClassNameId(),
3282 group.getClassPK(), StringPool.BLANK, friendlyURL);
3283
3284 validateFriendlyURL(
3285 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
3286 group.getClassPK(), friendlyURL);
3287
3288 group.setFriendlyURL(friendlyURL);
3289
3290 groupPersistence.update(group);
3291
3292 return group;
3293 }
3294
3295 @Override
3296 public Group updateGroup(
3297 long groupId, long parentGroupId, Map<Locale, String> nameMap,
3298 Map<Locale, String> descriptionMap, int type,
3299 boolean manualMembership, int membershipRestriction,
3300 String friendlyURL, boolean inheritContent, boolean active,
3301 ServiceContext serviceContext)
3302 throws PortalException {
3303
3304 Group group = groupPersistence.findByPrimaryKey(groupId);
3305
3306 String className = group.getClassName();
3307 long classNameId = group.getClassNameId();
3308 long classPK = group.getClassPK();
3309
3310 String groupKey = group.getGroupKey();
3311
3312 if ((nameMap != null) &&
3313 Validator.isNotNull(nameMap.get(LocaleUtil.getDefault()))) {
3314
3315 groupKey = nameMap.get(LocaleUtil.getDefault());
3316 }
3317
3318 friendlyURL = getFriendlyURL(
3319 group.getCompanyId(), groupId, classNameId, classPK,
3320 StringPool.BLANK, friendlyURL);
3321
3322 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
3323 validateGroupKey(
3324 group.getGroupId(), group.getCompanyId(), groupKey,
3325 group.isSite());
3326 }
3327 else if (className.equals(Organization.class.getName())) {
3328 Organization organization =
3329 organizationPersistence.findByPrimaryKey(classPK);
3330
3331 groupKey = getOrgGroupName(organization.getName());
3332 }
3333 else if (!GroupConstants.USER_PERSONAL_SITE.equals(
3334 group.getGroupKey())) {
3335
3336 groupKey = String.valueOf(classPK);
3337 }
3338
3339 if (PortalUtil.isSystemGroup(group.getGroupKey()) &&
3340 !groupKey.equals(group.getGroupKey())) {
3341
3342 throw new RequiredGroupException.MustNotDeleteSystemGroup(
3343 group.getGroupId());
3344 }
3345
3346 validateFriendlyURL(
3347 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
3348 group.getClassPK(), friendlyURL);
3349
3350 validateParentGroup(group.getGroupId(), parentGroupId);
3351
3352 group.setParentGroupId(parentGroupId);
3353 group.setTreePath(group.buildTreePath());
3354 group.setGroupKey(groupKey);
3355 group.setNameMap(nameMap);
3356 group.setDescriptionMap(descriptionMap);
3357 group.setType(type);
3358 group.setManualMembership(manualMembership);
3359 group.setMembershipRestriction(membershipRestriction);
3360 group.setFriendlyURL(friendlyURL);
3361 group.setInheritContent(inheritContent);
3362 group.setActive(active);
3363
3364 if ((serviceContext != null) && group.isSite()) {
3365 group.setExpandoBridgeAttributes(serviceContext);
3366 }
3367
3368 groupPersistence.update(group);
3369
3370
3371
3372 if ((serviceContext == null) || !group.isSite()) {
3373 return group;
3374 }
3375
3376 User user = null;
3377
3378 user = userPersistence.fetchByPrimaryKey(group.getCreatorUserId());
3379
3380 if (user == null) {
3381 user = userPersistence.fetchByPrimaryKey(
3382 serviceContext.getUserId());
3383 }
3384
3385 if (user == null) {
3386 user = userLocalService.getDefaultUser(group.getCompanyId());
3387 }
3388
3389 updateAsset(
3390 user.getUserId(), group, serviceContext.getAssetCategoryIds(),
3391 serviceContext.getAssetTagNames());
3392
3393 return group;
3394 }
3395
3396
3424 @Deprecated
3425 @Override
3426 public Group updateGroup(
3427 long groupId, long parentGroupId, String name, String description,
3428 int type, boolean manualMembership, int membershipRestriction,
3429 String friendlyURL, boolean inheritContent, boolean active,
3430 ServiceContext serviceContext)
3431 throws PortalException {
3432
3433 return updateGroup(
3434 groupId, parentGroupId, getLocalizationMap(name),
3435 getLocalizationMap(description), type, manualMembership,
3436 membershipRestriction, friendlyURL, inheritContent, active,
3437 serviceContext);
3438 }
3439
3440
3450 @Override
3451 public Group updateGroup(long groupId, String typeSettings)
3452 throws PortalException {
3453
3454 Group group = groupPersistence.findByPrimaryKey(groupId);
3455
3456 UnicodeProperties oldTypeSettingsProperties =
3457 group.getTypeSettingsProperties();
3458
3459 UnicodeProperties typeSettingsProperties = new UnicodeProperties(true);
3460
3461 typeSettingsProperties.fastLoad(typeSettings);
3462
3463 String newLanguageIds = typeSettingsProperties.getProperty(
3464 PropsKeys.LOCALES);
3465
3466 if (Validator.isNotNull(newLanguageIds)) {
3467 String oldLanguageIds = oldTypeSettingsProperties.getProperty(
3468 PropsKeys.LOCALES, StringPool.BLANK);
3469
3470 String defaultLanguageId = typeSettingsProperties.getProperty(
3471 "languageId", LocaleUtil.toLanguageId(LocaleUtil.getDefault()));
3472
3473 validateLanguageIds(defaultLanguageId, newLanguageIds);
3474
3475 if (!Validator.equals(oldLanguageIds, newLanguageIds)) {
3476 LanguageUtil.resetAvailableGroupLocales(groupId);
3477 }
3478 }
3479
3480 group.setTypeSettings(typeSettings);
3481
3482 groupPersistence.update(group);
3483
3484 return group;
3485 }
3486
3487
3496 @Override
3497 public Group updateSite(long groupId, boolean site) throws PortalException {
3498 Group group = groupPersistence.findByPrimaryKey(groupId);
3499
3500 if (!group.isOrganization()) {
3501 return group;
3502 }
3503
3504 group.setSite(site);
3505
3506 groupPersistence.update(group);
3507
3508 return group;
3509 }
3510
3511 protected void addControlPanelLayouts(Group group) throws PortalException {
3512 long defaultUserId = userLocalService.getDefaultUserId(
3513 group.getCompanyId());
3514
3515 String friendlyURL = getFriendlyURL(
3516 PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
3517
3518 ServiceContext serviceContext = new ServiceContext();
3519
3520 layoutLocalService.addLayout(
3521 defaultUserId, group.getGroupId(), true,
3522 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
3523 PropsValues.CONTROL_PANEL_LAYOUT_NAME, StringPool.BLANK,
3524 StringPool.BLANK, LayoutConstants.TYPE_CONTROL_PANEL, false,
3525 friendlyURL, serviceContext);
3526 }
3527
3528 protected void addDefaultGuestPublicLayoutByProperties(Group group)
3529 throws PortalException {
3530
3531 List<Portlet> portlets = portletLocalService.getPortlets(
3532 group.getCompanyId());
3533
3534 if (portlets.isEmpty()) {
3535
3536
3537
3538 return;
3539 }
3540
3541 long defaultUserId = userLocalService.getDefaultUserId(
3542 group.getCompanyId());
3543 String friendlyURL = getFriendlyURL(
3544 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
3545
3546 ServiceContext serviceContext = new ServiceContext();
3547
3548 Layout layout = layoutLocalService.addLayout(
3549 defaultUserId, group.getGroupId(), false,
3550 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
3551 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
3552 StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL,
3553 serviceContext);
3554
3555 LayoutTypePortlet layoutTypePortlet =
3556 (LayoutTypePortlet)layout.getLayoutType();
3557
3558 layoutTypePortlet.setLayoutTemplateId(
3559 0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
3560
3561 LayoutTemplate layoutTemplate = layoutTypePortlet.getLayoutTemplate();
3562
3563 for (String columnId : layoutTemplate.getColumns()) {
3564 String keyPrefix = PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_PREFIX;
3565
3566 String portletIds = PropsUtil.get(keyPrefix.concat(columnId));
3567
3568 layoutTypePortlet.addPortletIds(
3569 0, StringUtil.split(portletIds), columnId, false);
3570 }
3571
3572 layoutLocalService.updateLayout(
3573 layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
3574 layout.getTypeSettings());
3575
3576 boolean updateLayoutSet = false;
3577
3578 LayoutSet layoutSet = layout.getLayoutSet();
3579
3580 if (Validator.isNotNull(
3581 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
3582
3583 layoutSet.setThemeId(
3584 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
3585
3586 updateLayoutSet = true;
3587 }
3588
3589 if (Validator.isNotNull(
3590 PropsValues.
3591 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
3592
3593 layoutSet.setColorSchemeId(
3594 PropsValues.
3595 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
3596
3597 updateLayoutSet = true;
3598 }
3599
3600 if (Validator.isNotNull(
3601 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
3602
3603 layoutSet.setWapThemeId(
3604 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
3605
3606 updateLayoutSet = true;
3607 }
3608
3609 if (Validator.isNotNull(
3610 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
3611
3612 layoutSet.setWapColorSchemeId(
3613 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
3614
3615 updateLayoutSet = true;
3616 }
3617
3618 if (updateLayoutSet) {
3619 layoutSetLocalService.updateLayoutSet(layoutSet);
3620 }
3621 }
3622
3623 protected void addDefaultGuestPublicLayouts(Group group)
3624 throws PortalException {
3625
3626 if (publicLARFile != null) {
3627 addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
3628 }
3629 else {
3630 addDefaultGuestPublicLayoutByProperties(group);
3631 }
3632 }
3633
3634 protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
3635 throws PortalException {
3636
3637 User defaultUser = userLocalService.getDefaultUser(
3638 group.getCompanyId());
3639
3640 Map<String, String[]> parameterMap = new HashMap<>();
3641
3642 parameterMap.put(
3643 PortletDataHandlerKeys.PERMISSIONS,
3644 new String[] {Boolean.TRUE.toString()});
3645 parameterMap.put(
3646 PortletDataHandlerKeys.PORTLET_CONFIGURATION,
3647 new String[] {Boolean.TRUE.toString()});
3648 parameterMap.put(
3649 PortletDataHandlerKeys.PORTLET_DATA,
3650 new String[] {Boolean.TRUE.toString()});
3651 parameterMap.put(
3652 PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
3653 new String[] {Boolean.TRUE.toString()});
3654
3655 Map<String, Serializable> settingsMap =
3656 ExportImportConfigurationSettingsMapFactory.buildImportSettingsMap(
3657 defaultUser.getUserId(), group.getGroupId(), false, null,
3658 parameterMap, Constants.IMPORT, defaultUser.getLocale(),
3659 defaultUser.getTimeZone(), larFile.getName());
3660
3661 ExportImportConfiguration exportImportConfiguration =
3662 exportImportConfigurationLocalService.addExportImportConfiguration(
3663 defaultUser.getUserId(), group.getGroupId(), StringPool.BLANK,
3664 StringPool.BLANK,
3665 ExportImportConfigurationConstants.TYPE_IMPORT_LAYOUT,
3666 settingsMap, WorkflowConstants.STATUS_DRAFT,
3667 new ServiceContext());
3668
3669 exportImportLocalService.importLayouts(
3670 exportImportConfiguration, larFile);
3671 }
3672
3673 protected void addPortletDefaultData(Group group) throws PortalException {
3674 PortletDataContext portletDataContext =
3675 PortletDataContextFactoryUtil.createPreparePortletDataContext(
3676 group.getCompanyId(), group.getGroupId(), null, null);
3677
3678 List<PortletDataHandler> portletDataHandlers = getPortletDataHandlers(
3679 group);
3680
3681 for (PortletDataHandler portletDataHandler : portletDataHandlers) {
3682 try {
3683 portletDataHandler.addDefaultData(
3684 portletDataContext, portletDataHandler.getPortletId(),
3685 null);
3686 }
3687 catch (Exception e) {
3688 _log.error(
3689 "Unable to add default data for portlet " +
3690 portletDataHandler.getPortletId() + " in group " +
3691 group.getGroupId());
3692
3693 if (portletDataHandler.isRollbackOnException()) {
3694 throw new SystemException(e);
3695 }
3696 }
3697 }
3698 }
3699
3700 protected void addUserPersonalPanelLayouts(Group group)
3701 throws PortalException {
3702
3703 long defaultUserId = userLocalService.getDefaultUserId(
3704 group.getCompanyId());
3705
3706 String friendlyURL = getFriendlyURL(
3707 PropsValues.USER_PERSONAL_PANEL_LAYOUT_FRIENDLY_URL);
3708
3709 ServiceContext serviceContext = new ServiceContext();
3710
3711 layoutLocalService.addLayout(
3712 defaultUserId, group.getGroupId(), true,
3713 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
3714 PropsValues.USER_PERSONAL_PANEL_LAYOUT_NAME, StringPool.BLANK,
3715 StringPool.BLANK, LayoutConstants.TYPE_USER_PERSONAL_PANEL, false,
3716 friendlyURL, serviceContext);
3717 }
3718
3719 protected void deletePortletData(Group group) throws PortalException {
3720 PortletDataContext portletDataContext =
3721 PortletDataContextFactoryUtil.createPreparePortletDataContext(
3722 group.getCompanyId(), group.getGroupId(), null, null);
3723
3724 List<PortletDataHandler> portletDataHandlers = getPortletDataHandlers(
3725 group);
3726
3727 for (PortletDataHandler portletDataHandler : portletDataHandlers) {
3728 try {
3729 portletDataHandler.deleteData(
3730 portletDataContext, portletDataHandler.getPortletId(),
3731 null);
3732 }
3733 catch (Exception e) {
3734 _log.error(
3735 "Unable to delete data for portlet " +
3736 portletDataHandler.getPortletId() + " in group " +
3737 group.getGroupId());
3738
3739 if (portletDataHandler.isRollbackOnException()) {
3740 throw new SystemException(e);
3741 }
3742 }
3743 }
3744 }
3745
3746 protected Collection<Group> doSearch(
3747 long companyId, long[] classNameIds, long parentGroupId, String[] names,
3748 String[] descriptions, LinkedHashMap<String, Object> params,
3749 boolean andOperator) {
3750
3751 boolean parentGroupIdEquals = true;
3752
3753 if (parentGroupId == GroupConstants.ANY_PARENT_GROUP_ID) {
3754 parentGroupIdEquals = false;
3755 }
3756
3757 params = new LinkedHashMap<>(params);
3758
3759 Boolean active = (Boolean)params.remove("active");
3760 List<Long> excludedGroupIds = (List<Long>)params.remove(
3761 "excludedGroupIds");
3762 List<Group> groupsTree = (List<Group>)params.remove("groupsTree");
3763 Boolean manualMembership = (Boolean)params.remove("manualMembership");
3764 Integer membershipRestriction = (Integer)params.remove(
3765 "membershipRestriction");
3766 Boolean site = (Boolean)params.remove("site");
3767 List<Integer> types = (List<Integer>)params.remove("types");
3768
3769 Collection<Group> groups = new HashSet<>();
3770
3771 Long userId = (Long)params.remove("usersGroups");
3772
3773 for (long classNameId : classNameIds) {
3774 groups.addAll(groupPersistence.findByC_C(companyId, classNameId));
3775 }
3776
3777 Iterator<Group> iterator = groups.iterator();
3778
3779 while (iterator.hasNext()) {
3780 Group group = iterator.next();
3781
3782
3783
3784 long liveGroupId = group.getLiveGroupId();
3785
3786 if (liveGroupId != 0) {
3787 iterator.remove();
3788
3789 continue;
3790 }
3791
3792
3793
3794 long groupParentGroupId = group.getParentGroupId();
3795
3796 if ((parentGroupIdEquals &&
3797 (groupParentGroupId != parentGroupId)) ||
3798 (!parentGroupIdEquals &&
3799 (groupParentGroupId == parentGroupId))) {
3800
3801 iterator.remove();
3802
3803 continue;
3804 }
3805
3806
3807
3808 String groupKey = group.getGroupKey();
3809
3810 if (groupKey.equals(GroupConstants.CONTROL_PANEL) ||
3811 groupKey.equals(GroupConstants.USER_PERSONAL_PANEL)) {
3812
3813 iterator.remove();
3814
3815 continue;
3816 }
3817
3818 boolean containsName = matches(group.getNameCurrentValue(), names);
3819 boolean containsDescription = matches(
3820 group.getDescriptionCurrentValue(), descriptions);
3821
3822 if ((andOperator && (!containsName || !containsDescription)) ||
3823 (!andOperator && !containsName && !containsDescription)) {
3824
3825 iterator.remove();
3826
3827 continue;
3828 }
3829
3830
3831
3832 if (active != null) {
3833 if (active != group.isActive()) {
3834 iterator.remove();
3835
3836 continue;
3837 }
3838 }
3839
3840
3841
3842 if ((excludedGroupIds != null) &&
3843 excludedGroupIds.contains(group.getGroupId())) {
3844
3845 iterator.remove();
3846
3847 continue;
3848 }
3849
3850
3851
3852 if (groupsTree != null) {
3853 String treePath = group.getTreePath();
3854
3855 boolean matched = false;
3856
3857 for (Group groupTree : groupsTree) {
3858 String groupTreePath = StringUtil.quote(
3859 String.valueOf(groupTree.getGroupId()),
3860 StringPool.SLASH);
3861
3862 if (treePath.contains(groupTreePath)) {
3863 matched = true;
3864
3865 break;
3866 }
3867 }
3868
3869 if (!matched) {
3870 iterator.remove();
3871
3872 continue;
3873 }
3874 }
3875
3876
3877
3878 if ((manualMembership != null) &&
3879 (manualMembership != group.isManualMembership())) {
3880
3881 iterator.remove();
3882
3883 continue;
3884 }
3885
3886
3887
3888 if ((membershipRestriction != null) &&
3889 (membershipRestriction != group.getMembershipRestriction())) {
3890
3891 iterator.remove();
3892
3893 continue;
3894 }
3895
3896
3897
3898 if (site != null) {
3899 if (site != group.isSite()) {
3900 iterator.remove();
3901
3902 continue;
3903 }
3904 }
3905
3906
3907
3908 int type = group.getType();
3909
3910 if (type == 4) {
3911 iterator.remove();
3912
3913 continue;
3914 }
3915
3916 if ((types != null) && !types.contains(type)) {
3917 iterator.remove();
3918
3919 continue;
3920 }
3921 }
3922
3923
3924
3925 List<?> rolePermissions = (List<?>)params.remove("rolePermissions");
3926
3927 if (rolePermissions != null) {
3928 String resourceName = (String)rolePermissions.get(0);
3929 Integer resourceScope = (Integer)rolePermissions.get(1);
3930 String resourceActionId = (String)rolePermissions.get(2);
3931 Long resourceRoleId = (Long)rolePermissions.get(3);
3932
3933 ResourceAction resourceAction =
3934 resourceActionLocalService.fetchResourceAction(
3935 resourceName, resourceActionId);
3936
3937 if (resourceAction != null) {
3938 Set<Group> rolePermissionsGroups = new HashSet<>();
3939
3940 if (resourceBlockLocalService.isSupported(resourceName)) {
3941 List<ResourceTypePermission> resourceTypePermissions =
3942 resourceTypePermissionPersistence.findByRoleId(
3943 resourceRoleId);
3944
3945 for (ResourceTypePermission resourceTypePermission :
3946 resourceTypePermissions) {
3947
3948 if ((resourceTypePermission.getCompanyId() ==
3949 companyId) &&
3950 resourceName.equals(
3951 resourceTypePermission.getName()) &&
3952 resourceTypePermission.hasAction(resourceAction)) {
3953
3954 Group group = groupPersistence.fetchByPrimaryKey(
3955 resourceTypePermission.getGroupId());
3956
3957 if (group != null) {
3958 rolePermissionsGroups.add(group);
3959 }
3960 }
3961 }
3962 }
3963 else {
3964 List<ResourcePermission> resourcePermissions =
3965 resourcePermissionPersistence.findByC_N_S(
3966 companyId, resourceName, resourceScope);
3967
3968 for (ResourcePermission resourcePermission :
3969 resourcePermissions) {
3970
3971 if ((resourcePermission.getRoleId() ==
3972 resourceRoleId) &&
3973 resourcePermission.hasAction(
3974 resourceAction)) {
3975
3976 Group group = groupPersistence.fetchByPrimaryKey(
3977 GetterUtil.getLong(
3978 resourcePermission.getPrimKey()));
3979
3980 if (group != null) {
3981 rolePermissionsGroups.add(group);
3982 }
3983 }
3984 }
3985 }
3986
3987 groups.retainAll(rolePermissionsGroups);
3988 }
3989 }
3990
3991 if (userId == null) {
3992 return groups;
3993 }
3994
3995
3996
3997 Set<Group> joinedGroups = new HashSet<>(
3998 userPersistence.getGroups(userId));
3999
4000 boolean inherit = GetterUtil.getBoolean(params.remove("inherit"), true);
4001
4002 if (inherit) {
4003
4004
4005
4006 long[] organizationIds = userPersistence.getOrganizationPrimaryKeys(
4007 userId);
4008
4009 for (long organizationId : organizationIds) {
4010 for (Group group : groups) {
4011 if (organizationId == group.getClassPK()) {
4012 joinedGroups.add(group);
4013 }
4014 }
4015 }
4016
4017
4018
4019 for (long organizationId : organizationIds) {
4020 joinedGroups.addAll(
4021 organizationPersistence.getGroups(organizationId));
4022 }
4023
4024
4025
4026 long[] userGroupIds = userPersistence.getUserGroupPrimaryKeys(
4027 userId);
4028
4029 for (long userGroupId : userGroupIds) {
4030 joinedGroups.addAll(
4031 userGroupPersistence.getGroups(userGroupId));
4032 }
4033 }
4034
4035 if (_log.isDebugEnabled() && !params.isEmpty()) {
4036 _log.debug("Unprocessed parameters " + MapUtil.toString(params));
4037 }
4038
4039
4040
4041 Long roleId = (Long)params.remove("groupsRoles");
4042
4043 if (roleId != null) {
4044 joinedGroups.retainAll(rolePersistence.getGroups(roleId));
4045 }
4046
4047 if (joinedGroups.size() > groups.size()) {
4048 groups.retainAll(joinedGroups);
4049
4050 return groups;
4051 }
4052 else {
4053 joinedGroups.retainAll(groups);
4054
4055 return joinedGroups;
4056 }
4057 }
4058
4059 protected long[] getClassNameIds() {
4060 if (_classNameIds == null) {
4061 _classNameIds = new long[] {
4062 classNameLocalService.getClassNameId(Group.class),
4063 classNameLocalService.getClassNameId(Organization.class)
4064 };
4065 }
4066
4067 return _classNameIds;
4068 }
4069
4070 protected String getFriendlyURL(
4071 long companyId, long groupId, long classNameId, long classPK,
4072 String friendlyName, String friendlyURL)
4073 throws PortalException {
4074
4075 friendlyURL = getFriendlyURL(friendlyURL);
4076
4077 if (Validator.isNotNull(friendlyURL)) {
4078 return friendlyURL;
4079 }
4080
4081 friendlyURL = StringPool.SLASH + getFriendlyURL(friendlyName);
4082
4083 String originalFriendlyURL = friendlyURL;
4084
4085 for (int i = 1;; i++) {
4086 try {
4087 validateFriendlyURL(
4088 companyId, groupId, classNameId, classPK, friendlyURL);
4089
4090 break;
4091 }
4092 catch (GroupFriendlyURLException gfurle) {
4093 int type = gfurle.getType();
4094
4095 if (type == GroupFriendlyURLException.DUPLICATE) {
4096 friendlyURL = originalFriendlyURL + i;
4097 }
4098 else {
4099 friendlyURL = StringPool.SLASH + classPK;
4100
4101 break;
4102 }
4103 }
4104 }
4105
4106 return friendlyURL;
4107 }
4108
4109 protected String getFriendlyURL(String friendlyURL) {
4110 return FriendlyURLNormalizerUtil.normalize(friendlyURL);
4111 }
4112
4113 protected String getOrgGroupName(String name) {
4114 return name + ORGANIZATION_NAME_SUFFIX;
4115 }
4116
4117 protected List<PortletDataHandler> getPortletDataHandlers(Group group) {
4118 List<Portlet> portlets = portletLocalService.getPortlets(
4119 group.getCompanyId());
4120
4121 List<PortletDataHandler> portletDataHandlers = new ArrayList<>(
4122 portlets.size());
4123
4124 for (Portlet portlet : portlets) {
4125 if (!portlet.isActive()) {
4126 continue;
4127 }
4128
4129 PortletDataHandler portletDataHandler =
4130 portlet.getPortletDataHandlerInstance();
4131
4132 if ((portletDataHandler != null) &&
4133 !portletDataHandler.isDataPortalLevel()) {
4134
4135 portletDataHandlers.add(portletDataHandler);
4136 }
4137 }
4138
4139 return portletDataHandlers;
4140 }
4141
4142 protected String[] getSearchNames(long companyId, String name) {
4143 if (Validator.isNull(name)) {
4144 return new String[] {null};
4145 }
4146
4147 Company company = companyPersistence.fetchByPrimaryKey(companyId);
4148
4149 if (company == null) {
4150 return CustomSQLUtil.keywords(name);
4151 }
4152
4153 Account account = accountPersistence.fetchByPrimaryKey(
4154 company.getAccountId());
4155
4156 if (account == null) {
4157 return CustomSQLUtil.keywords(name);
4158 }
4159
4160 String companyName = account.getName();
4161
4162 if (StringUtil.wildcardMatches(
4163 companyName, name, CharPool.UNDERLINE, CharPool.PERCENT,
4164 CharPool.BACK_SLASH, false)) {
4165
4166 String[] searchNames = CustomSQLUtil.keywords(name);
4167
4168 String guestName = StringUtil.quote(
4169 StringUtil.toLowerCase(GroupConstants.GUEST),
4170 StringPool.PERCENT);
4171
4172 return ArrayUtil.append(searchNames, guestName);
4173 }
4174
4175 return CustomSQLUtil.keywords(name);
4176 }
4177
4178 protected void initImportLARFile() {
4179 String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
4180
4181 if (_log.isDebugEnabled()) {
4182 _log.debug("Reading public LAR file " + publicLARFileName);
4183 }
4184
4185 if (Validator.isNotNull(publicLARFileName)) {
4186 publicLARFile = new File(publicLARFileName);
4187
4188 if (!publicLARFile.exists()) {
4189 _log.error(
4190 "Public LAR file " + publicLARFile + " does not exist");
4191
4192 publicLARFile = null;
4193 }
4194 else {
4195 if (_log.isDebugEnabled()) {
4196 _log.debug("Using public LAR file " + publicLARFileName);
4197 }
4198 }
4199 }
4200 }
4201
4202 protected void initUserPersonalSitePermissions(Group group)
4203 throws PortalException {
4204
4205
4206
4207 Role role = roleLocalService.getRole(
4208 group.getCompanyId(), RoleConstants.USER);
4209
4210 setRolePermissions(
4211 group, role, Layout.class.getName(),
4212 new String[] {ActionKeys.VIEW});
4213
4214 setRolePermissions(
4215 group, role, "com.liferay.portlet.blogs",
4216 new String[] {
4217 ActionKeys.ADD_ENTRY, ActionKeys.PERMISSIONS,
4218 ActionKeys.SUBSCRIBE
4219 });
4220
4221
4222
4223 role = roleLocalService.getRole(
4224 group.getCompanyId(), RoleConstants.POWER_USER);
4225
4226 List<Portlet> portlets = portletLocalService.getPortlets(
4227 group.getCompanyId(), false, false);
4228
4229 for (Portlet portlet : portlets) {
4230 List<String> actions =
4231 ResourceActionsUtil.getPortletResourceActions(
4232 portlet.getPortletId());
4233
4234 String controlPanelEntryCategory = GetterUtil.getString(
4235 portlet.getControlPanelEntryCategory());
4236
4237 if (actions.contains(ActionKeys.ACCESS_IN_CONTROL_PANEL) &&
4238 controlPanelEntryCategory.startsWith(
4239 PortletCategoryKeys.SITE_ADMINISTRATION)) {
4240
4241 setRolePermissions(
4242 group, role, portlet.getPortletId(),
4243 new String[] {ActionKeys.ACCESS_IN_CONTROL_PANEL});
4244 }
4245 }
4246
4247 setRolePermissions(
4248 group, role, Group.class.getName(),
4249 new String[] {
4250 ActionKeys.MANAGE_LAYOUTS, ActionKeys.VIEW_SITE_ADMINISTRATION
4251 });
4252
4253 setRolePermissions(group, role, "com.liferay.portlet.asset");
4254 setRolePermissions(group, role, "com.liferay.portlet.blogs");
4255 setRolePermissions(group, role, "com.liferay.portlet.bookmarks");
4256 setRolePermissions(group, role, "com.liferay.portlet.documentlibrary");
4257 setRolePermissions(group, role, "com.liferay.portlet.imagegallery");
4258 setRolePermissions(group, role, "com.liferay.portlet.journal");
4259 setRolePermissions(group, role, "com.liferay.portlet.messageboards");
4260 setRolePermissions(group, role, "com.liferay.portlet.wiki");
4261 }
4262
4263 protected boolean isParentGroup(long parentGroupId, long groupId)
4264 throws PortalException {
4265
4266
4267
4268 if (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4269 return false;
4270 }
4271
4272 Group group = groupPersistence.findByPrimaryKey(groupId);
4273
4274 String treePath = group.getTreePath();
4275
4276 if (treePath.contains(
4277 StringPool.SLASH + parentGroupId + StringPool.SLASH)) {
4278
4279 return true;
4280 }
4281 else {
4282 return false;
4283 }
4284 }
4285
4286 protected boolean isStaging(ServiceContext serviceContext) {
4287 if (serviceContext != null) {
4288 return ParamUtil.getBoolean(serviceContext, "staging");
4289 }
4290
4291 return false;
4292 }
4293
4294 protected boolean isUseComplexSQL(long[] classNameIds) {
4295 if (ArrayUtil.isEmpty(classNameIds)) {
4296 return true;
4297 }
4298
4299 if (_complexSQLClassNameIds == null) {
4300 String[] complexSQLClassNames =
4301 PropsValues.GROUPS_COMPLEX_SQL_CLASS_NAMES;
4302
4303 long[] complexSQLClassNameIds =
4304 new long[complexSQLClassNames.length];
4305
4306 for (int i = 0; i < complexSQLClassNames.length; i++) {
4307 String complexSQLClassName = complexSQLClassNames[i];
4308
4309 complexSQLClassNameIds[i] =
4310 classNameLocalService.getClassNameId(complexSQLClassName);
4311 }
4312
4313 _complexSQLClassNameIds = complexSQLClassNameIds;
4314 }
4315
4316 for (long classNameId : classNameIds) {
4317 if (ArrayUtil.contains(_complexSQLClassNameIds, classNameId)) {
4318 return true;
4319 }
4320 }
4321
4322 return false;
4323 }
4324
4325 protected boolean matches(String s, String[] keywords) {
4326 if ((keywords == null) ||
4327 ((keywords.length == 1) && (keywords[0] == null))) {
4328
4329 return true;
4330 }
4331
4332 for (String keyword : keywords) {
4333 if (StringUtil.wildcardMatches(
4334 s, keyword, CharPool.UNDERLINE, CharPool.PERCENT,
4335 CharPool.BACK_SLASH, false)) {
4336
4337 return true;
4338 }
4339 }
4340
4341 return false;
4342 }
4343
4344 protected void setCompanyPermissions(
4345 Role role, String name, String[] actionIds)
4346 throws PortalException {
4347
4348 if (resourceBlockLocalService.isSupported(name)) {
4349 resourceBlockLocalService.setCompanyScopePermissions(
4350 role.getCompanyId(), name, role.getRoleId(),
4351 Arrays.asList(actionIds));
4352 }
4353 else {
4354 resourcePermissionLocalService.setResourcePermissions(
4355 role.getCompanyId(), name, ResourceConstants.SCOPE_COMPANY,
4356 String.valueOf(role.getCompanyId()), role.getRoleId(),
4357 actionIds);
4358 }
4359 }
4360
4361 protected void setRolePermissions(Group group, Role role, String name)
4362 throws PortalException {
4363
4364 List<String> actions = ResourceActionsUtil.getModelResourceActions(
4365 name);
4366
4367 setRolePermissions(
4368 group, role, name, actions.toArray(new String[actions.size()]));
4369 }
4370
4371 protected void setRolePermissions(
4372 Group group, Role role, String name, String[] actionIds)
4373 throws PortalException {
4374
4375 if (resourceBlockLocalService.isSupported(name)) {
4376 resourceBlockLocalService.setGroupScopePermissions(
4377 role.getCompanyId(), group.getGroupId(), name, role.getRoleId(),
4378 Arrays.asList(actionIds));
4379 }
4380 else {
4381 resourcePermissionLocalService.setResourcePermissions(
4382 group.getCompanyId(), name, ResourceConstants.SCOPE_GROUP,
4383 String.valueOf(group.getGroupId()), role.getRoleId(),
4384 actionIds);
4385 }
4386 }
4387
4388 protected List<Group> sort(
4389 Collection<Group> groups, int start, int end,
4390 OrderByComparator<Group> obc) {
4391
4392 if (obc == null) {
4393 obc = new GroupNameComparator(true);
4394 }
4395
4396 List<Group> groupList = null;
4397
4398 if (groups instanceof List) {
4399 groupList = (List<Group>)groups;
4400 }
4401 else {
4402 groupList = new ArrayList<>(groups);
4403 }
4404
4405 Collections.sort(groupList, obc);
4406
4407 return Collections.unmodifiableList(
4408 ListUtil.subList(groupList, start, end));
4409 }
4410
4411 protected void unscheduleStaging(Group group) {
4412 try {
4413
4414
4415
4416 String groupName = StagingUtil.getSchedulerGroupName(
4417 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
4418
4419 SchedulerEngineHelperUtil.delete(groupName, StorageType.PERSISTED);
4420
4421 long liveGroupId = 0;
4422 long stagingGroupId = 0;
4423
4424 if (group.isStagingGroup()) {
4425 liveGroupId = group.getLiveGroupId();
4426
4427 stagingGroupId = group.getGroupId();
4428 }
4429 else if (group.hasStagingGroup()) {
4430 liveGroupId = group.getGroupId();
4431
4432 stagingGroupId = group.getStagingGroup().getGroupId();
4433 }
4434
4435 if ((liveGroupId != 0) && (stagingGroupId != 0)) {
4436
4437
4438
4439 groupName = StagingUtil.getSchedulerGroupName(
4440 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
4441
4442 SchedulerEngineHelperUtil.delete(
4443 groupName, StorageType.PERSISTED);
4444
4445
4446
4447 groupName = StagingUtil.getSchedulerGroupName(
4448 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
4449
4450 SchedulerEngineHelperUtil.delete(
4451 groupName, StorageType.PERSISTED);
4452 }
4453 }
4454 catch (Exception e) {
4455 _log.error(
4456 "Unable to unschedule events for group: " + group.getGroupId());
4457 }
4458 }
4459
4460 protected void validateFriendlyURL(
4461 long companyId, long groupId, long classNameId, long classPK,
4462 String friendlyURL)
4463 throws PortalException {
4464
4465 Company company = companyPersistence.findByPrimaryKey(companyId);
4466
4467 if (company.isSystem()) {
4468 return;
4469 }
4470
4471 if (Validator.isNull(friendlyURL)) {
4472 return;
4473 }
4474
4475 int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
4476
4477 if (exceptionType != -1) {
4478 throw new GroupFriendlyURLException(exceptionType);
4479 }
4480
4481 Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
4482
4483 if ((group != null) && (group.getGroupId() != groupId)) {
4484 GroupFriendlyURLException gfurle = new GroupFriendlyURLException(
4485 GroupFriendlyURLException.DUPLICATE);
4486
4487 gfurle.setDuplicateClassPK(group.getGroupId());
4488 gfurle.setDuplicateClassName(Group.class.getName());
4489
4490 throw gfurle;
4491 }
4492
4493 String groupIdFriendlyURL = friendlyURL.substring(1);
4494
4495 if (Validator.isNumber(groupIdFriendlyURL)) {
4496 long groupClassNameId = classNameLocalService.getClassNameId(
4497 Group.class);
4498
4499 if (((classNameId != groupClassNameId) &&
4500 !groupIdFriendlyURL.equals(String.valueOf(classPK)) &&
4501 !PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC) ||
4502 ((classNameId == groupClassNameId) &&
4503 !groupIdFriendlyURL.equals(String.valueOf(groupId)))) {
4504
4505 GroupFriendlyURLException gfurle =
4506 new GroupFriendlyURLException(
4507 GroupFriendlyURLException.POSSIBLE_DUPLICATE);
4508
4509 gfurle.setKeywordConflict(groupIdFriendlyURL);
4510
4511 throw gfurle;
4512 }
4513 }
4514
4515 String screenName = friendlyURL.substring(1);
4516
4517 User user = userPersistence.fetchByC_SN(companyId, screenName);
4518
4519 if (user != null) {
4520 long userClassNameId = classNameLocalService.getClassNameId(
4521 User.class);
4522
4523 if ((classNameId == userClassNameId) &&
4524 (classPK == user.getUserId())) {
4525 }
4526 else {
4527 GroupFriendlyURLException gfurle =
4528 new GroupFriendlyURLException(
4529 GroupFriendlyURLException.DUPLICATE);
4530
4531 gfurle.setDuplicateClassPK(user.getUserId());
4532 gfurle.setDuplicateClassName(User.class.getName());
4533
4534 throw gfurle;
4535 }
4536 }
4537
4538 if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
4539 throw new GroupFriendlyURLException(
4540 GroupFriendlyURLException.TOO_DEEP);
4541 }
4542 }
4543
4544 protected void validateGroupKey(
4545 long groupId, long companyId, String groupKey, boolean site)
4546 throws PortalException {
4547
4548 if (Validator.isNull(groupKey) || Validator.isNumber(groupKey) ||
4549 groupKey.contains(StringPool.STAR) ||
4550 groupKey.contains(ORGANIZATION_NAME_SUFFIX)) {
4551
4552 throw new GroupKeyException();
4553 }
4554
4555 try {
4556 Group group = groupFinder.findByC_GK(companyId, groupKey);
4557
4558 if ((groupId <= 0) || (group.getGroupId() != groupId)) {
4559 throw new DuplicateGroupException("{groupId=" + groupId + "}");
4560 }
4561 }
4562 catch (NoSuchGroupException nsge) {
4563 }
4564
4565 if (site) {
4566 Company company = companyLocalService.getCompany(companyId);
4567
4568 if (groupKey.equals(company.getName())) {
4569 throw new DuplicateGroupException();
4570 }
4571 }
4572 }
4573
4574 protected void validateInheritContent(
4575 long parentGroupId, boolean inheritContent)
4576 throws GroupInheritContentException {
4577
4578 if (!inheritContent) {
4579 return;
4580 }
4581
4582 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4583 throw new GroupInheritContentException();
4584 }
4585
4586 Group parentGroup = groupPersistence.fetchByPrimaryKey(parentGroupId);
4587
4588 if (parentGroup.isInheritContent()) {
4589 throw new GroupInheritContentException();
4590 }
4591 }
4592
4593 protected void validateLanguageIds(
4594 String defaultLanguageId, String languageIds)
4595 throws PortalException {
4596
4597 String[] languageIdsArray = StringUtil.split(languageIds);
4598
4599 for (String languageId : languageIdsArray) {
4600 if (!LanguageUtil.isAvailableLocale(
4601 LocaleUtil.fromLanguageId(languageId))) {
4602
4603 LocaleException le = new LocaleException(
4604 LocaleException.TYPE_DISPLAY_SETTINGS);
4605
4606 le.setSourceAvailableLocales(
4607 LanguageUtil.getAvailableLocales());
4608 le.setTargetAvailableLocales(
4609 Arrays.asList(
4610 LocaleUtil.fromLanguageIds(languageIdsArray)));
4611
4612 throw le;
4613 }
4614 }
4615
4616 if (!ArrayUtil.contains(languageIdsArray, defaultLanguageId)) {
4617 LocaleException le = new LocaleException(
4618 LocaleException.TYPE_DEFAULT);
4619
4620 le.setSourceAvailableLocales(LanguageUtil.getAvailableLocales());
4621 le.setTargetAvailableLocales(
4622 Arrays.asList(LocaleUtil.fromLanguageIds(languageIdsArray)));
4623
4624 throw le;
4625 }
4626 }
4627
4628 protected void validateParentGroup(long groupId, long parentGroupId)
4629 throws PortalException {
4630
4631 if (parentGroupId == GroupConstants.DEFAULT_PARENT_GROUP_ID) {
4632 return;
4633 }
4634
4635 if (groupId == parentGroupId) {
4636 throw new GroupParentException.MustNotBeOwnParent(groupId);
4637 }
4638
4639 Group group = groupPersistence.fetchByPrimaryKey(groupId);
4640
4641 if (group == null) {
4642 return;
4643 }
4644
4645 if ((groupId > 0) &&
4646 (parentGroupId != GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
4647
4648
4649
4650 if (isParentGroup(groupId, parentGroupId)) {
4651 throw new GroupParentException.MustNotHaveChildParent(
4652 groupId, parentGroupId);
4653 }
4654 }
4655
4656 Group parentGroup = groupPersistence.findByPrimaryKey(parentGroupId);
4657
4658 if (group.isStagingGroup()) {
4659 long stagingGroupId = parentGroup.getStagingGroup().getGroupId();
4660
4661 if (groupId == stagingGroupId) {
4662 throw new GroupParentException.MustNotHaveStagingParent(
4663 groupId, stagingGroupId);
4664 }
4665 }
4666 }
4667
4668 protected File publicLARFile;
4669
4670 private static final Log _log = LogFactoryUtil.getLog(
4671 GroupLocalServiceImpl.class);
4672
4673 private volatile long[] _classNameIds;
4674 private volatile long[] _complexSQLClassNameIds;
4675 private final Map<String, Group> _systemGroupsMap = new HashMap<>();
4676
4677 }