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