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.GroupNameException;
020 import com.liferay.portal.NoSuchGroupException;
021 import com.liferay.portal.NoSuchLayoutSetException;
022 import com.liferay.portal.NoSuchUserException;
023 import com.liferay.portal.RequiredGroupException;
024 import com.liferay.portal.kernel.annotation.Propagation;
025 import com.liferay.portal.kernel.annotation.Transactional;
026 import com.liferay.portal.kernel.cache.ThreadLocalCachable;
027 import com.liferay.portal.kernel.dao.orm.QueryUtil;
028 import com.liferay.portal.kernel.exception.PortalException;
029 import com.liferay.portal.kernel.exception.SystemException;
030 import com.liferay.portal.kernel.lar.PortletDataHandlerKeys;
031 import com.liferay.portal.kernel.log.Log;
032 import com.liferay.portal.kernel.log.LogFactoryUtil;
033 import com.liferay.portal.kernel.messaging.DestinationNames;
034 import com.liferay.portal.kernel.scheduler.SchedulerEngineUtil;
035 import com.liferay.portal.kernel.scheduler.messaging.SchedulerRequest;
036 import com.liferay.portal.kernel.staging.StagingUtil;
037 import com.liferay.portal.kernel.util.CharPool;
038 import com.liferay.portal.kernel.util.GetterUtil;
039 import com.liferay.portal.kernel.util.OrderByComparator;
040 import com.liferay.portal.kernel.util.ParamUtil;
041 import com.liferay.portal.kernel.util.PropsKeys;
042 import com.liferay.portal.kernel.util.StringPool;
043 import com.liferay.portal.kernel.util.StringUtil;
044 import com.liferay.portal.kernel.util.UnicodeProperties;
045 import com.liferay.portal.kernel.util.Validator;
046 import com.liferay.portal.model.Account;
047 import com.liferay.portal.model.Company;
048 import com.liferay.portal.model.Group;
049 import com.liferay.portal.model.GroupConstants;
050 import com.liferay.portal.model.Layout;
051 import com.liferay.portal.model.LayoutConstants;
052 import com.liferay.portal.model.LayoutPrototype;
053 import com.liferay.portal.model.LayoutSet;
054 import com.liferay.portal.model.LayoutSetPrototype;
055 import com.liferay.portal.model.LayoutTypePortlet;
056 import com.liferay.portal.model.Organization;
057 import com.liferay.portal.model.Resource;
058 import com.liferay.portal.model.ResourceConstants;
059 import com.liferay.portal.model.Role;
060 import com.liferay.portal.model.RoleConstants;
061 import com.liferay.portal.model.User;
062 import com.liferay.portal.model.UserGroup;
063 import com.liferay.portal.model.impl.LayoutImpl;
064 import com.liferay.portal.security.permission.PermissionCacheUtil;
065 import com.liferay.portal.service.ServiceContext;
066 import com.liferay.portal.service.base.GroupLocalServiceBaseImpl;
067 import com.liferay.portal.util.FriendlyURLNormalizer;
068 import com.liferay.portal.util.PortalUtil;
069 import com.liferay.portal.util.PropsUtil;
070 import com.liferay.portal.util.PropsValues;
071 import com.liferay.portal.util.comparator.GroupNameComparator;
072 import com.liferay.portlet.blogs.model.BlogsEntry;
073 import com.liferay.portlet.journal.model.JournalArticle;
074 import com.liferay.util.UniqueList;
075
076 import java.io.File;
077
078 import java.util.ArrayList;
079 import java.util.HashMap;
080 import java.util.Iterator;
081 import java.util.LinkedHashMap;
082 import java.util.List;
083 import java.util.Map;
084
085
091 public class GroupLocalServiceImpl extends GroupLocalServiceBaseImpl {
092
093 public GroupLocalServiceImpl() {
094 initImportLARFile();
095 }
096
097 public Group addGroup(
098 long userId, String className, long classPK, String name,
099 String description, int type, String friendlyURL, boolean active,
100 ServiceContext serviceContext)
101 throws PortalException, SystemException {
102
103 return addGroup(
104 userId, className, classPK, GroupConstants.DEFAULT_LIVE_GROUP_ID,
105 name, description, type, friendlyURL, active, serviceContext);
106 }
107
108 public Group addGroup(
109 long userId, String className, long classPK, long liveGroupId,
110 String name, String description, int type, String friendlyURL,
111 boolean active, ServiceContext serviceContext)
112 throws PortalException, SystemException {
113
114
115
116 User user = userPersistence.findByPrimaryKey(userId);
117 className = GetterUtil.getString(className);
118 long classNameId = PortalUtil.getClassNameId(className);
119
120 String friendlyName = name;
121
122 if (className.equals(Organization.class.getName())) {
123 Organization organization =
124 organizationPersistence.findByPrimaryKey(classPK);
125
126 friendlyName = organization.getName();
127 name = String.valueOf(classPK);
128 }
129
130 long groupId = 0;
131
132 while (true) {
133 groupId = counterLocalService.increment();
134
135 User userScreenName = userPersistence.fetchByC_SN(
136 user.getCompanyId(), String.valueOf(groupId));
137
138 if (userScreenName == null) {
139 break;
140 }
141 }
142
143 boolean staging = isStaging(serviceContext);
144
145 long groupClassNameId = PortalUtil.getClassNameId(Group.class);
146
147 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
148 classNameId = groupClassNameId;
149 classPK = groupId;
150 }
151 else if (className.equals(Organization.class.getName()) && staging) {
152 classPK = liveGroupId;
153 }
154 else {
155 name = String.valueOf(classPK);
156 }
157
158 long parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
159
160 if (className.equals(Layout.class.getName())) {
161 Layout layout = layoutLocalService.getLayout(classPK);
162
163 parentGroupId = layout.getGroupId();
164 }
165
166 friendlyURL = getFriendlyURL(
167 user.getCompanyId(), groupId, classNameId, classPK, friendlyName,
168 friendlyURL);
169
170 if (staging) {
171 name = name.concat(" (Staging)");
172 friendlyURL = friendlyURL.concat("-staging");
173 }
174
175 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
176 validateName(groupId, user.getCompanyId(), name);
177 }
178
179 validateFriendlyURL(
180 user.getCompanyId(), groupId, classNameId, classPK, friendlyURL);
181
182 Group group = groupPersistence.create(groupId);
183
184 group.setCompanyId(user.getCompanyId());
185 group.setCreatorUserId(userId);
186 group.setClassNameId(classNameId);
187 group.setClassPK(classPK);
188 group.setParentGroupId(parentGroupId);
189 group.setLiveGroupId(liveGroupId);
190 group.setName(name);
191 group.setDescription(description);
192 group.setType(type);
193 group.setFriendlyURL(friendlyURL);
194 group.setActive(active);
195
196 groupPersistence.update(group, false);
197
198
199
200 layoutSetLocalService.addLayoutSet(groupId, true);
201
202 layoutSetLocalService.addLayoutSet(groupId, false);
203
204 if ((classNameId == groupClassNameId) && !user.isDefaultUser()) {
205
206
207
208 resourceLocalService.addResources(
209 group.getCompanyId(), 0, 0, Group.class.getName(),
210 group.getGroupId(), false, false, false);
211
212
213
214 Role role = roleLocalService.getRole(
215 group.getCompanyId(), RoleConstants.COMMUNITY_OWNER);
216
217 userGroupRoleLocalService.addUserGroupRoles(
218 userId, groupId, new long[] {role.getRoleId()});
219
220
221
222 userLocalService.addGroupUsers(
223 group.getGroupId(), new long[] {userId});
224
225
226
227 if (serviceContext != null) {
228 updateAsset(
229 userId, group, serviceContext.getAssetCategoryIds(),
230 serviceContext.getAssetTagNames());
231 }
232 }
233 else if (className.equals(Organization.class.getName()) &&
234 !user.isDefaultUser()) {
235
236
237
238 resourceLocalService.addResources(
239 group.getCompanyId(), 0, 0, Group.class.getName(),
240 group.getGroupId(), false, false, false);
241 }
242
243 return group;
244 }
245
246 public void addRoleGroups(long roleId, long[] groupIds)
247 throws SystemException {
248
249 rolePersistence.addGroups(roleId, groupIds);
250
251 PermissionCacheUtil.clearCache();
252 }
253
254 public void addUserGroups(long userId, long[] groupIds)
255 throws SystemException {
256
257 userPersistence.addGroups(userId, groupIds);
258
259 PermissionCacheUtil.clearCache();
260 }
261
262 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
263 public void checkCompanyGroup(long companyId)
264 throws PortalException, SystemException {
265
266 long classNameId = PortalUtil.getClassNameId(Company.class);
267
268 int count = groupPersistence.countByC_C_C(
269 companyId, classNameId, companyId);
270
271 if (count == 0) {
272 long defaultUserId = userLocalService.getDefaultUserId(companyId);
273
274 groupLocalService.addGroup(
275 defaultUserId, Company.class.getName(), companyId, null, null,
276 0, null, true, null);
277 }
278 }
279
280 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
281 public void checkSystemGroups(long companyId)
282 throws PortalException, SystemException {
283
284 for (Group group : groupFinder.findBySystem(companyId)) {
285 _systemGroupsMap.put(companyId + group.getName(), group);
286 }
287
288 long defaultUserId = userLocalService.getDefaultUserId(companyId);
289
290 String[] systemGroups = PortalUtil.getSystemGroups();
291
292 for (String name : systemGroups) {
293 Group group = _systemGroupsMap.get(companyId + name);
294
295 try {
296 if (group == null) {
297 group = groupPersistence.findByC_N(companyId, name);
298 }
299 }
300 catch (NoSuchGroupException nsge) {
301 int type = GroupConstants.TYPE_COMMUNITY_OPEN;
302 String friendlyURL = null;
303
304 if (name.equals(GroupConstants.CONTROL_PANEL)) {
305 type = GroupConstants.TYPE_COMMUNITY_PRIVATE;
306 friendlyURL = GroupConstants.CONTROL_PANEL_FRIENDLY_URL;
307 }
308 else if (name.equals(GroupConstants.GUEST)) {
309 friendlyURL = "/guest";
310 }
311
312 group = groupLocalService.addGroup(
313 defaultUserId, null, 0, name, null, type, friendlyURL,
314 true, null);
315 }
316
317 if (group.isControlPanel()) {
318 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
319 group.getGroupId(), true);
320
321 if (layoutSet.getPageCount() == 0) {
322 addControlPanelLayouts(group);
323 }
324 }
325
326 if (group.getName().equals(GroupConstants.GUEST)) {
327 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
328 group.getGroupId(), false);
329
330 if (layoutSet.getPageCount() == 0) {
331 addDefaultGuestPublicLayouts(group);
332 }
333 }
334
335 _systemGroupsMap.put(companyId + name, group);
336 }
337 }
338
339 public void deleteGroup(long groupId)
340 throws PortalException, SystemException {
341
342 Group group = groupPersistence.findByPrimaryKey(groupId);
343
344 if (PortalUtil.isSystemGroup(group.getName())) {
345 throw new RequiredGroupException(String.valueOf(groupId));
346 }
347
348
349
350 try {
351 layoutSetLocalService.deleteLayoutSet(groupId, true);
352 }
353 catch (NoSuchLayoutSetException nslse) {
354 }
355
356 try {
357 layoutSetLocalService.deleteLayoutSet(groupId, false);
358 }
359 catch (NoSuchLayoutSetException nslse) {
360 }
361
362
363
364 userGroupRoleLocalService.deleteUserGroupRolesByGroupId(groupId);
365
366
367
368 userGroupGroupRoleLocalService.deleteUserGroupGroupRolesByGroupId(
369 groupId);
370
371
372
373 membershipRequestLocalService.deleteMembershipRequests(
374 group.getGroupId());
375
376
377
378 subscriptionLocalService.deleteSubscriptions(
379 group.getCompanyId(), BlogsEntry.class.getName(),
380 group.getGroupId());
381 subscriptionLocalService.deleteSubscriptions(
382 group.getCompanyId(), JournalArticle.class.getName(),
383 group.getGroupId());
384
385
386
387 teamLocalService.deleteTeams(group.getGroupId());
388
389
390
391 unscheduleStaging(group);
392
393 if (group.hasStagingGroup()) {
394 deleteGroup(group.getStagingGroup().getGroupId());
395 }
396
397
398
399 if (group.isCommunity()) {
400 assetEntryLocalService.deleteEntry(Group.class.getName(), groupId);
401 }
402
403
404
405 blogsEntryLocalService.deleteEntries(groupId);
406 blogsStatsUserLocalService.deleteStatsUserByGroupId(groupId);
407
408
409
410 bookmarksFolderLocalService.deleteFolders(groupId);
411
412
413
414 calEventLocalService.deleteEvents(groupId);
415
416
417
418 dlFolderLocalService.deleteFolders(groupId);
419
420
421
422 igFolderLocalService.deleteFolders(groupId);
423
424
425
426 journalArticleLocalService.deleteArticles(groupId);
427 journalTemplateLocalService.deleteTemplates(groupId);
428 journalStructureLocalService.deleteStructures(groupId);
429
430
431
432 mbBanLocalService.deleteBansByGroupId(groupId);
433 mbCategoryLocalService.deleteCategories(groupId);
434 mbStatsUserLocalService.deleteStatsUsersByGroupId(groupId);
435
436
437
438 pollsQuestionLocalService.deleteQuestions(groupId);
439
440
441
442 shoppingCartLocalService.deleteGroupCarts(groupId);
443 shoppingCategoryLocalService.deleteCategories(groupId);
444 shoppingCouponLocalService.deleteCoupons(groupId);
445 shoppingOrderLocalService.deleteOrders(groupId);
446
447
448
449 scFrameworkVersionLocalService.deleteFrameworkVersions(groupId);
450 scProductEntryLocalService.deleteProductEntries(groupId);
451
452
453
454 wikiNodeLocalService.deleteNodes(groupId);
455
456
457
458 Iterator<Resource> itr = resourceFinder.findByC_P(
459 group.getCompanyId(), String.valueOf(groupId)).iterator();
460
461 while (itr.hasNext()) {
462 Resource resource = itr.next();
463
464 resourceLocalService.deleteResource(resource);
465 }
466
467 if (!group.isStagingGroup() &&
468 (group.isCommunity() || group.isOrganization())) {
469
470 resourceLocalService.deleteResource(
471 group.getCompanyId(), Group.class.getName(),
472 ResourceConstants.SCOPE_INDIVIDUAL, group.getGroupId());
473 }
474
475
476
477 groupPersistence.remove(group);
478
479
480
481 PermissionCacheUtil.clearCache();
482 }
483
484 public Group getCompanyGroup(long companyId)
485 throws PortalException, SystemException {
486
487 long classNameId = PortalUtil.getClassNameId(Company.class);
488
489 return groupPersistence.findByC_C_C(companyId, classNameId, companyId);
490 }
491
492 public List<Group> getCompanyGroups(long companyId, int start, int end)
493 throws SystemException {
494
495 return groupPersistence.findByCompanyId(companyId, start, end);
496 }
497
498 public int getCompanyGroupsCount(long companyId) throws SystemException {
499 return groupPersistence.countByCompanyId(companyId);
500 }
501
502 public Group getFriendlyURLGroup(long companyId, String friendlyURL)
503 throws PortalException, SystemException {
504
505 if (Validator.isNull(friendlyURL)) {
506 throw new NoSuchGroupException();
507 }
508
509 friendlyURL = getFriendlyURL(friendlyURL);
510
511 return groupPersistence.findByC_F(companyId, friendlyURL);
512 }
513
514 public Group getGroup(long groupId)
515 throws PortalException, SystemException {
516
517 return groupPersistence.findByPrimaryKey(groupId);
518 }
519
520 public Group getGroup(long companyId, String name)
521 throws PortalException, SystemException {
522
523 Group group = _systemGroupsMap.get(companyId + name);
524
525 if (group != null) {
526 return group;
527 }
528
529 return groupPersistence.findByC_N(companyId, name);
530 }
531
532 public List<Group> getGroups(long[] groupIds)
533 throws PortalException, SystemException {
534
535 List<Group> groups = new ArrayList<Group>(groupIds.length);
536
537 for (long groupId : groupIds) {
538 Group group = getGroup(groupId);
539
540 groups.add(group);
541 }
542
543 return groups;
544 }
545
546 public Group getLayoutGroup(long companyId, long plid)
547 throws PortalException, SystemException {
548
549 long classNameId = PortalUtil.getClassNameId(Layout.class);
550
551 return groupPersistence.findByC_C_C(companyId, classNameId, plid);
552 }
553
554 public Group getLayoutPrototypeGroup(long companyId, long layoutPrototypeId)
555 throws PortalException, SystemException {
556
557 long classNameId = PortalUtil.getClassNameId(LayoutPrototype.class);
558
559 return groupPersistence.findByC_C_C(
560 companyId, classNameId, layoutPrototypeId);
561 }
562
563 public Group getLayoutSetPrototypeGroup(
564 long companyId, long layoutSetPrototypeId)
565 throws PortalException, SystemException {
566
567 long classNameId = PortalUtil.getClassNameId(LayoutSetPrototype.class);
568
569 return groupPersistence.findByC_C_C(
570 companyId, classNameId, layoutSetPrototypeId);
571 }
572
573 public List<Group> getLiveGroups() throws SystemException {
574 return groupFinder.findByLiveGroups();
575 }
576
577 public List<Group> getNoLayoutsGroups(
578 String className, boolean privateLayout, int start, int end)
579 throws SystemException {
580
581 long classNameId = PortalUtil.getClassNameId(className);
582
583 return groupFinder.findByNoLayouts(
584 classNameId, privateLayout, start, end);
585 }
586
587 public List<Group> getNullFriendlyURLGroups() throws SystemException {
588 return groupFinder.findByNullFriendlyURL();
589 }
590
591 public Group getOrganizationGroup(long companyId, long organizationId)
592 throws PortalException, SystemException {
593
594 long classNameId = PortalUtil.getClassNameId(Organization.class);
595
596 return groupPersistence.findByC_C_C(
597 companyId, classNameId, organizationId);
598 }
599
600 public List<Group> getOrganizationsGroups(
601 List<Organization> organizations) {
602
603 List<Group> organizationGroups = new ArrayList<Group>();
604
605 for (int i = 0; i < organizations.size(); i++) {
606 Organization organization = organizations.get(i);
607
608 Group group = organization.getGroup();
609
610 organizationGroups.add(group);
611 }
612
613 return organizationGroups;
614 }
615
616 public List<Group> getOrganizationsRelatedGroups(
617 List<Organization> organizations)
618 throws SystemException {
619
620 List<Group> organizationGroups = new ArrayList<Group>();
621
622 for (int i = 0; i < organizations.size(); i++) {
623 Organization organization = organizations.get(i);
624
625 List<Group> groups = organizationPersistence.getGroups(
626 organization.getOrganizationId());
627
628 organizationGroups.addAll(groups);
629 }
630
631 return organizationGroups;
632 }
633
634 public List<Group> getRoleGroups(long roleId) throws SystemException {
635 return rolePersistence.getGroups(roleId);
636 }
637
638 public Group getStagingGroup(long liveGroupId)
639 throws PortalException, SystemException {
640
641 return groupPersistence.findByLiveGroupId(liveGroupId);
642 }
643
644 public Group getUserGroup(long companyId, long userId)
645 throws PortalException, SystemException {
646
647 long classNameId = PortalUtil.getClassNameId(User.class);
648
649 return groupPersistence.findByC_C_C(companyId, classNameId, userId);
650 }
651
652 public Group getUserGroupGroup(long companyId, long userGroupId)
653 throws PortalException, SystemException {
654
655 long classNameId = PortalUtil.getClassNameId(UserGroup.class);
656
657 return groupPersistence.findByC_C_C(
658 companyId, classNameId, userGroupId);
659 }
660
661 public List<Group> getUserGroups(long userId)
662 throws PortalException, SystemException {
663
664 return getUserGroups(userId, false);
665 }
666
667 public List<Group> getUserGroups(long userId, boolean inherit)
668 throws PortalException, SystemException {
669
670 return getUserGroups(
671 userId, inherit, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
672 }
673
674 public List<Group> getUserGroups(long userId, int start, int end)
675 throws PortalException, SystemException {
676
677 return getUserGroups(userId, false, start, end);
678 }
679
680 public List<Group> getUserGroups(
681 long userId, boolean inherit, int start, int end)
682 throws PortalException, SystemException {
683
684 if (inherit) {
685 User user = userPersistence.findByPrimaryKey(userId);
686
687 LinkedHashMap<String, Object> groupParams =
688 new LinkedHashMap<String, Object>();
689
690 groupParams.put("usersGroups", new Long(userId));
691
692 return search(
693 user.getCompanyId(), null, null, groupParams, start, end);
694 }
695 else {
696 return userPersistence.getGroups(userId);
697 }
698 }
699
700 public List<Group> getUserGroupsGroups(List<UserGroup> userGroups)
701 throws PortalException, SystemException {
702
703 List<Group> userGroupGroups = new ArrayList<Group>();
704
705 for (int i = 0; i < userGroups.size(); i++) {
706 UserGroup userGroup = userGroups.get(i);
707
708 Group group = userGroup.getGroup();
709
710 userGroupGroups.add(group);
711 }
712
713 return userGroupGroups;
714 }
715
716 public List<Group> getUserGroupsRelatedGroups(List<UserGroup> userGroups)
717 throws SystemException {
718
719 List<Group> userGroupGroups = new ArrayList<Group>();
720
721 for (int i = 0; i < userGroups.size(); i++) {
722 UserGroup userGroup = userGroups.get(i);
723
724 List<Group> groups = userGroupPersistence.getGroups(
725 userGroup.getUserGroupId());
726
727 userGroupGroups.addAll(groups);
728 }
729
730 return userGroupGroups;
731 }
732
733 public List<Group> getUserOrganizationsGroups(
734 long userId, int start, int end)
735 throws PortalException, SystemException {
736
737 List<Group> userOrgsGroups = new UniqueList<Group>();
738
739 List<Organization> userOrgs =
740 organizationLocalService.getUserOrganizations(
741 userId, true, start, end);
742
743 for (Organization organization : userOrgs) {
744 userOrgsGroups.add(0, organization.getGroup());
745
746 if (!PropsValues.ORGANIZATIONS_MEMBERSHIP_STRICT) {
747 for (Organization ancestorOrganization :
748 organization.getAncestors()) {
749
750 userOrgsGroups.add(0, ancestorOrganization.getGroup());
751 }
752 }
753 }
754
755 return userOrgsGroups;
756 }
757
758 public boolean hasRoleGroup(long roleId, long groupId)
759 throws SystemException {
760
761 return rolePersistence.containsGroup(roleId, groupId);
762 }
763
764 public boolean hasStagingGroup(long liveGroupId) throws SystemException {
765 if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
766 return true;
767 }
768 else {
769 return false;
770 }
771 }
772
773 public boolean hasUserGroup(long userId, long groupId)
774 throws SystemException {
775
776 if (groupFinder.countByG_U(groupId, userId) > 0) {
777 return true;
778 }
779 else {
780 return false;
781 }
782 }
783
784 public List<Group> search(
785 long companyId, long[] classNameIds, String name,
786 String description, LinkedHashMap<String, Object> params, int start,
787 int end)
788 throws SystemException {
789
790 return search(
791 companyId, classNameIds, name, description, params, start, end,
792 null);
793 }
794
795 public List<Group> search(
796 long companyId, long[] classNameIds, String name,
797 String description, LinkedHashMap<String, Object> params, int start,
798 int end, OrderByComparator obc)
799 throws SystemException {
800
801 if (obc == null) {
802 obc = new GroupNameComparator(true);
803 }
804
805 String realName = getRealName(companyId, name);
806
807 return groupFinder.findByC_C_N_D(
808 companyId, classNameIds, name, realName, description, params, start,
809 end, obc);
810 }
811
812 public List<Group> search(
813 long companyId, String name, String description,
814 LinkedHashMap<String, Object> params, int start, int end)
815 throws SystemException {
816
817 return search(companyId, name, description, params, start, end, null);
818 }
819
820 public List<Group> search(
821 long companyId, String name, String description,
822 LinkedHashMap<String, Object> params, int start, int end,
823 OrderByComparator obc)
824 throws SystemException {
825
826 if (obc == null) {
827 obc = new GroupNameComparator(true);
828 }
829
830 String realName = getRealName(companyId, name);
831
832 return groupFinder.findByC_N_D(
833 companyId, name, realName, description, params, start, end, obc);
834 }
835
836 @ThreadLocalCachable
837 public int searchCount(
838 long companyId, String name, String description,
839 LinkedHashMap<String, Object> params)
840 throws SystemException {
841
842 String realName = getRealName(companyId, name);
843
844 return groupFinder.countByC_N_D(
845 companyId, name, realName, description, params);
846 }
847
848 @ThreadLocalCachable
849 public int searchCount(
850 long companyId, long[] classNameIds, String name,
851 String description, LinkedHashMap<String, Object> params)
852 throws SystemException {
853
854 String realName = getRealName(companyId, name);
855
856 return groupFinder.countByC_C_N_D(
857 companyId, classNameIds, name, realName, description, params);
858 }
859
860 public void setRoleGroups(long roleId, long[] groupIds)
861 throws SystemException {
862
863 rolePersistence.setGroups(roleId, groupIds);
864
865 PermissionCacheUtil.clearCache();
866 }
867
868 public void unsetRoleGroups(long roleId, long[] groupIds)
869 throws SystemException {
870
871 rolePersistence.removeGroups(roleId, groupIds);
872
873 PermissionCacheUtil.clearCache();
874 }
875
876 public void unsetUserGroups(long userId, long[] groupIds)
877 throws SystemException {
878
879 userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
880
881 userPersistence.removeGroups(userId, groupIds);
882
883 PermissionCacheUtil.clearCache();
884 }
885
886 public void updateAsset(
887 long userId, Group group, long[] assetCategoryIds,
888 String[] assetTagNames)
889 throws PortalException, SystemException {
890
891 User user = userPersistence.findByPrimaryKey(userId);
892
893 Company company = companyPersistence.findByPrimaryKey(
894 user.getCompanyId());
895
896 Group companyGroup = company.getGroup();
897
898 assetEntryLocalService.updateEntry(
899 userId, companyGroup.getGroupId(), Group.class.getName(),
900 group.getGroupId(), null, assetCategoryIds, assetTagNames, false,
901 null, null, null, null, null, group.getDescriptiveName(),
902 group.getDescription(), null, null, 0, 0, null, false);
903 }
904
905 public Group updateFriendlyURL(long groupId, String friendlyURL)
906 throws PortalException, SystemException {
907
908 Group group = groupPersistence.findByPrimaryKey(groupId);
909
910 if (group.isUser()) {
911 User user = userPersistence.findByPrimaryKey(group.getClassPK());
912
913 friendlyURL = StringPool.SLASH + user.getScreenName();
914
915 if (group.getFriendlyURL().equals(friendlyURL)) {
916 return group;
917 }
918 }
919
920 friendlyURL = getFriendlyURL(
921 group.getCompanyId(), groupId, group.getClassNameId(),
922 group.getClassPK(), StringPool.BLANK, friendlyURL);
923
924 validateFriendlyURL(
925 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
926 group.getClassPK(), friendlyURL);
927
928 group.setFriendlyURL(friendlyURL);
929
930 groupPersistence.update(group, false);
931
932 return group;
933 }
934
935 public Group updateGroup(
936 long groupId, String name, String description, int type,
937 String friendlyURL, boolean active, ServiceContext serviceContext)
938 throws PortalException, SystemException {
939
940 Group group = groupPersistence.findByPrimaryKey(groupId);
941
942 String className = group.getClassName();
943 long classNameId = group.getClassNameId();
944 long classPK = group.getClassPK();
945 friendlyURL = getFriendlyURL(
946 group.getCompanyId(), groupId, classNameId, classPK,
947 StringPool.BLANK, friendlyURL);
948
949 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
950 validateName(group.getGroupId(), group.getCompanyId(), name);
951 }
952 else {
953 name = String.valueOf(classPK);
954 }
955
956 if (PortalUtil.isSystemGroup(group.getName()) &&
957 !group.getName().equals(name)) {
958
959 throw new RequiredGroupException();
960 }
961
962 validateFriendlyURL(
963 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
964 group.getClassPK(), friendlyURL);
965
966 group.setName(name);
967 group.setDescription(description);
968 group.setType(type);
969 group.setFriendlyURL(friendlyURL);
970 group.setActive(active);
971
972 groupPersistence.update(group, false);
973
974
975
976 if ((serviceContext != null) && group.isCommunity()) {
977 User user = null;
978
979 try {
980 user = userPersistence.findByPrimaryKey(
981 group.getCreatorUserId());
982
983 }
984 catch (NoSuchUserException nsue1) {
985 try {
986 user = userPersistence.findByPrimaryKey(
987 serviceContext.getUserId());
988 }
989 catch (NoSuchUserException nsue2) {
990 user = userLocalService.getDefaultUser(
991 group.getCompanyId());
992 }
993 }
994
995 updateAsset(
996 user.getUserId(), group, serviceContext.getAssetCategoryIds(),
997 serviceContext.getAssetTagNames());
998 }
999
1000 return group;
1001 }
1002
1003 public Group updateGroup(long groupId, String typeSettings)
1004 throws PortalException, SystemException {
1005
1006 Group group = groupPersistence.findByPrimaryKey(groupId);
1007
1008 group.setTypeSettings(typeSettings);
1009
1010 groupPersistence.update(group, false);
1011
1012 return group;
1013 }
1014
1015 public Group updateWorkflow(
1016 long groupId, boolean workflowEnabled, int workflowStages,
1017 String workflowRoleNames)
1018 throws PortalException, SystemException {
1019
1020 Group group = groupPersistence.findByPrimaryKey(groupId);
1021
1022 UnicodeProperties props = group.getTypeSettingsProperties();
1023
1024 props.setProperty("workflowEnabled", String.valueOf(workflowEnabled));
1025
1026 if (workflowEnabled) {
1027 if (workflowStages < PropsValues.TASKS_DEFAULT_STAGES) {
1028 workflowStages = PropsValues.TASKS_DEFAULT_STAGES;
1029 }
1030
1031 if (Validator.isNull(workflowRoleNames)) {
1032 workflowRoleNames = PropsValues.TASKS_DEFAULT_ROLE_NAMES;
1033 }
1034
1035 props.setProperty("workflowStages", String.valueOf(workflowStages));
1036 props.setProperty("workflowRoleNames", workflowRoleNames);
1037 }
1038
1039 group.setTypeSettings(group.getTypeSettings());
1040
1041 groupPersistence.update(group, false);
1042
1043 if (!workflowEnabled) {
1044 tasksProposalLocalService.deleteProposals(groupId);
1045 }
1046
1047 return group;
1048 }
1049
1050 protected void addControlPanelLayouts(Group group)
1051 throws PortalException, SystemException {
1052
1053 long defaultUserId = userLocalService.getDefaultUserId(
1054 group.getCompanyId());
1055
1056 String friendlyURL = getFriendlyURL(
1057 PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
1058
1059 ServiceContext serviceContext = new ServiceContext();
1060
1061 layoutLocalService.addLayout(
1062 defaultUserId, group.getGroupId(), true,
1063 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
1064 PropsValues.CONTROL_PANEL_LAYOUT_NAME, StringPool.BLANK,
1065 StringPool.BLANK, LayoutConstants.TYPE_CONTROL_PANEL, false,
1066 friendlyURL, serviceContext);
1067 }
1068
1069 protected void addDefaultGuestPublicLayoutByProperties(Group group)
1070 throws PortalException, SystemException {
1071
1072 long defaultUserId = userLocalService.getDefaultUserId(
1073 group.getCompanyId());
1074 String friendlyURL = getFriendlyURL(
1075 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
1076
1077 ServiceContext serviceContext = new ServiceContext();
1078
1079 Layout layout = layoutLocalService.addLayout(
1080 defaultUserId, group.getGroupId(), false,
1081 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
1082 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
1083 StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL,
1084 serviceContext);
1085
1086 LayoutTypePortlet layoutTypePortlet =
1087 (LayoutTypePortlet)layout.getLayoutType();
1088
1089 layoutTypePortlet.setLayoutTemplateId(
1090 0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
1091
1092 for (int i = 0; i < 10; i++) {
1093 String columnId = "column-" + i;
1094 String portletIds = PropsUtil.get(
1095 PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_COLUMN + i);
1096
1097 layoutTypePortlet.addPortletIds(
1098 0, StringUtil.split(portletIds), columnId, false);
1099 }
1100
1101 layoutLocalService.updateLayout(
1102 layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
1103 layout.getTypeSettings());
1104
1105 boolean updateLayoutSet = false;
1106
1107 LayoutSet layoutSet = layout.getLayoutSet();
1108
1109 if (Validator.isNotNull(
1110 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
1111
1112 layoutSet.setThemeId(
1113 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
1114
1115 updateLayoutSet = true;
1116 }
1117
1118 if (Validator.isNotNull(
1119 PropsValues.
1120 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
1121
1122 layoutSet.setColorSchemeId(
1123 PropsValues.
1124 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
1125
1126 updateLayoutSet = true;
1127 }
1128
1129 if (Validator.isNotNull(
1130 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
1131
1132 layoutSet.setWapThemeId(
1133 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
1134
1135 updateLayoutSet = true;
1136 }
1137
1138 if (Validator.isNotNull(
1139 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
1140
1141 layoutSet.setWapColorSchemeId(
1142 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
1143
1144 updateLayoutSet = true;
1145 }
1146
1147 if (updateLayoutSet) {
1148 layoutSetLocalService.updateLayoutSet(layoutSet);
1149 }
1150 }
1151
1152 protected void addDefaultGuestPublicLayouts(Group group)
1153 throws PortalException, SystemException {
1154
1155 if (publicLARFile != null) {
1156 addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
1157 }
1158 else {
1159 addDefaultGuestPublicLayoutByProperties(group);
1160 }
1161 }
1162
1163 protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
1164 throws PortalException, SystemException {
1165
1166 long defaultUserId = userLocalService.getDefaultUserId(
1167 group.getCompanyId());
1168
1169 Map<String, String[]> parameterMap = new HashMap<String, String[]>();
1170
1171 parameterMap.put(
1172 PortletDataHandlerKeys.CATEGORIES,
1173 new String[] {Boolean.TRUE.toString()});
1174 parameterMap.put(
1175 PortletDataHandlerKeys.PERMISSIONS,
1176 new String[] {Boolean.TRUE.toString()});
1177 parameterMap.put(
1178 PortletDataHandlerKeys.PORTLET_DATA,
1179 new String[] {Boolean.TRUE.toString()});
1180 parameterMap.put(
1181 PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
1182 new String[] {Boolean.TRUE.toString()});
1183 parameterMap.put(
1184 PortletDataHandlerKeys.PORTLET_SETUP,
1185 new String[] {Boolean.TRUE.toString()});
1186 parameterMap.put(
1187 PortletDataHandlerKeys.USER_PERMISSIONS,
1188 new String[] {Boolean.FALSE.toString()});
1189
1190 layoutLocalService.importLayouts(
1191 defaultUserId, group.getGroupId(), false, parameterMap, larFile);
1192 }
1193
1194 protected String getFriendlyURL(String friendlyURL) {
1195 return FriendlyURLNormalizer.normalize(friendlyURL);
1196 }
1197
1198 protected String getFriendlyURL(
1199 long companyId, long groupId, long classNameId, long classPK,
1200 String friendlyName, String friendlyURL)
1201 throws PortalException, SystemException {
1202
1203 friendlyURL = getFriendlyURL(friendlyURL);
1204
1205 if (Validator.isNull(friendlyURL)) {
1206 friendlyURL = StringPool.SLASH + getFriendlyURL(friendlyName);
1207
1208 String originalFriendlyURL = friendlyURL;
1209
1210 for (int i = 1;; i++) {
1211 try {
1212 validateFriendlyURL(
1213 companyId, groupId, classNameId, classPK, friendlyURL);
1214
1215 break;
1216 }
1217 catch (GroupFriendlyURLException gfurle) {
1218 int type = gfurle.getType();
1219
1220 if (type == GroupFriendlyURLException.DUPLICATE) {
1221 friendlyURL = originalFriendlyURL + i;
1222 }
1223 else {
1224 friendlyURL = StringPool.SLASH + classPK;
1225
1226 break;
1227 }
1228 }
1229 }
1230 }
1231
1232 return friendlyURL;
1233 }
1234
1235 protected String getRealName(long companyId, String name)
1236 throws SystemException {
1237
1238 if (Validator.isNull(name)) {
1239 return name;
1240 }
1241
1242 String realName = name;
1243
1244 try {
1245 Company company = companyLocalService.getCompany(companyId);
1246
1247 Account account = company.getAccount();
1248
1249 String companyName = account.getName();
1250
1251 name = StringUtil.replace(
1252 name, StringPool.PERCENT, StringPool.BLANK);
1253
1254 if (companyName.indexOf(name) != -1) {
1255 realName = StringPool.PERCENT + GroupConstants.GUEST +
1256 StringPool.PERCENT;
1257 }
1258 }
1259 catch (PortalException pe) {
1260 }
1261
1262 return realName;
1263 }
1264
1265 protected boolean isStaging(ServiceContext serviceContext) {
1266 if (serviceContext != null) {
1267 return ParamUtil.getBoolean(serviceContext, "staging");
1268 }
1269
1270 return false;
1271 }
1272
1273 protected void initImportLARFile() {
1274 String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
1275
1276 if (_log.isDebugEnabled()) {
1277 _log.debug("Reading public LAR file " + publicLARFileName);
1278 }
1279
1280 if (Validator.isNotNull(publicLARFileName)) {
1281 publicLARFile = new File(publicLARFileName);
1282
1283 if (!publicLARFile.exists()) {
1284 _log.error(
1285 "Public LAR file " + publicLARFile + " does not exist");
1286
1287 publicLARFile = null;
1288 }
1289 else {
1290 if (_log.isDebugEnabled()) {
1291 _log.debug("Using public LAR file " + publicLARFileName);
1292 }
1293 }
1294 }
1295 }
1296
1297 protected void unscheduleStaging(Group group) {
1298 try {
1299
1300
1301
1302 String groupName = StagingUtil.getSchedulerGroupName(
1303 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
1304
1305 List<SchedulerRequest> schedulerRequests =
1306 SchedulerEngineUtil.getScheduledJobs(groupName);
1307
1308 for (SchedulerRequest schedulerRequest : schedulerRequests) {
1309 SchedulerEngineUtil.unschedule(schedulerRequest.getTrigger());
1310 }
1311
1312 long liveGroupId = 0;
1313 long stagingGroupId = 0;
1314
1315 if (group.isStagingGroup()) {
1316 liveGroupId = group.getLiveGroupId();
1317
1318 stagingGroupId = group.getGroupId();
1319 }
1320 else if (group.hasStagingGroup()) {
1321 liveGroupId = group.getGroupId();
1322
1323 stagingGroupId = group.getStagingGroup().getGroupId();
1324 }
1325
1326 if ((liveGroupId != 0) && (stagingGroupId != 0)) {
1327
1328
1329
1330 groupName = StagingUtil.getSchedulerGroupName(
1331 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
1332
1333 schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
1334 groupName);
1335
1336 for (SchedulerRequest schedulerRequest : schedulerRequests) {
1337 SchedulerEngineUtil.unschedule(
1338 schedulerRequest.getTrigger());
1339 }
1340
1341
1342
1343 groupName = StagingUtil.getSchedulerGroupName(
1344 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
1345
1346 schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
1347 groupName);
1348
1349 for (SchedulerRequest schedulerRequest : schedulerRequests) {
1350 SchedulerEngineUtil.unschedule(
1351 schedulerRequest.getTrigger());
1352 }
1353 }
1354 }
1355 catch (Exception e) {
1356 _log.error(
1357 "Unable to unschedule events for group: " + group.getGroupId());
1358 }
1359 }
1360
1361 protected void validateFriendlyURL(
1362 long companyId, long groupId, long classNameId, long classPK,
1363 String friendlyURL)
1364 throws PortalException, SystemException {
1365
1366 Company company = companyPersistence.findByPrimaryKey(companyId);
1367
1368 if (company.isSystem()) {
1369 return;
1370 }
1371
1372 if (Validator.isNull(friendlyURL)) {
1373 return;
1374 }
1375
1376 int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
1377
1378 if (exceptionType != -1) {
1379 throw new GroupFriendlyURLException(exceptionType);
1380 }
1381
1382 Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
1383
1384 if ((group != null) && (group.getGroupId() != groupId)) {
1385 throw new GroupFriendlyURLException(
1386 GroupFriendlyURLException.DUPLICATE);
1387 }
1388
1389 String groupIdFriendlyURL = friendlyURL.substring(1);
1390
1391 if (Validator.isNumber(groupIdFriendlyURL)) {
1392 long groupClassNameId = PortalUtil.getClassNameId(Group.class);
1393
1394 if (((classNameId != groupClassNameId) &&
1395 (!groupIdFriendlyURL.equals(String.valueOf(classPK))) &&
1396 (!PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC)) ||
1397 ((classNameId == groupClassNameId) &&
1398 (!groupIdFriendlyURL.equals(String.valueOf(groupId))))) {
1399
1400 GroupFriendlyURLException gfurle =
1401 new GroupFriendlyURLException(
1402 GroupFriendlyURLException.POSSIBLE_DUPLICATE);
1403
1404 gfurle.setKeywordConflict(groupIdFriendlyURL);
1405
1406 throw gfurle;
1407 }
1408 }
1409
1410 String screenName = friendlyURL.substring(1);
1411
1412 User user = userPersistence.fetchByC_SN(companyId, screenName);
1413
1414 if (user != null) {
1415 long userClassNameId = PortalUtil.getClassNameId(User.class);
1416
1417 if ((classNameId == userClassNameId) &&
1418 (classPK == user.getUserId())) {
1419 }
1420 else {
1421 throw new GroupFriendlyURLException(
1422 GroupFriendlyURLException.DUPLICATE);
1423 }
1424 }
1425
1426 if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
1427 throw new GroupFriendlyURLException(
1428 GroupFriendlyURLException.TOO_DEEP);
1429 }
1430 }
1431
1432 protected void validateName(long groupId, long companyId, String name)
1433 throws PortalException, SystemException {
1434
1435 if ((Validator.isNull(name)) || (Validator.isNumber(name)) ||
1436 (name.indexOf(CharPool.STAR) != -1)) {
1437
1438 throw new GroupNameException();
1439 }
1440
1441 try {
1442 Group group = groupFinder.findByC_N(companyId, name);
1443
1444 if ((groupId <= 0) || (group.getGroupId() != groupId)) {
1445 throw new DuplicateGroupException();
1446 }
1447 }
1448 catch (NoSuchGroupException nsge) {
1449 }
1450 }
1451
1452 protected File publicLARFile;
1453
1454 private static Log _log = LogFactoryUtil.getLog(
1455 GroupLocalServiceImpl.class);
1456
1457 private Map<String, Group> _systemGroupsMap = new HashMap<String, Group>();
1458
1459 }