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