1
14
15 package com.liferay.portal.service.impl;
16
17 import com.liferay.portal.DuplicateGroupException;
18 import com.liferay.portal.GroupFriendlyURLException;
19 import com.liferay.portal.GroupNameException;
20 import com.liferay.portal.NoSuchGroupException;
21 import com.liferay.portal.NoSuchLayoutSetException;
22 import com.liferay.portal.NoSuchRoleException;
23 import com.liferay.portal.PortalException;
24 import com.liferay.portal.RequiredGroupException;
25 import com.liferay.portal.SystemException;
26 import com.liferay.portal.kernel.annotation.Propagation;
27 import com.liferay.portal.kernel.annotation.Transactional;
28 import com.liferay.portal.kernel.dao.orm.QueryUtil;
29 import com.liferay.portal.kernel.log.Log;
30 import com.liferay.portal.kernel.log.LogFactoryUtil;
31 import com.liferay.portal.kernel.messaging.DestinationNames;
32 import com.liferay.portal.kernel.scheduler.SchedulerEngineUtil;
33 import com.liferay.portal.kernel.scheduler.messaging.SchedulerRequest;
34 import com.liferay.portal.kernel.util.GetterUtil;
35 import com.liferay.portal.kernel.util.OrderByComparator;
36 import com.liferay.portal.kernel.util.PropsKeys;
37 import com.liferay.portal.kernel.util.StringPool;
38 import com.liferay.portal.kernel.util.StringUtil;
39 import com.liferay.portal.kernel.util.UnicodeProperties;
40 import com.liferay.portal.kernel.util.Validator;
41 import com.liferay.portal.lar.PortletDataHandlerKeys;
42 import com.liferay.portal.model.Company;
43 import com.liferay.portal.model.Group;
44 import com.liferay.portal.model.GroupConstants;
45 import com.liferay.portal.model.Layout;
46 import com.liferay.portal.model.LayoutConstants;
47 import com.liferay.portal.model.LayoutSet;
48 import com.liferay.portal.model.LayoutTypePortlet;
49 import com.liferay.portal.model.Organization;
50 import com.liferay.portal.model.Resource;
51 import com.liferay.portal.model.ResourceConstants;
52 import com.liferay.portal.model.Role;
53 import com.liferay.portal.model.RoleConstants;
54 import com.liferay.portal.model.User;
55 import com.liferay.portal.model.UserGroup;
56 import com.liferay.portal.model.impl.LayoutImpl;
57 import com.liferay.portal.security.permission.PermissionCacheUtil;
58 import com.liferay.portal.service.base.GroupLocalServiceBaseImpl;
59 import com.liferay.portal.util.FriendlyURLNormalizer;
60 import com.liferay.portal.util.PortalUtil;
61 import com.liferay.portal.util.PropsUtil;
62 import com.liferay.portal.util.PropsValues;
63 import com.liferay.portal.util.comparator.GroupNameComparator;
64 import com.liferay.portlet.communities.util.StagingUtil;
65
66 import java.io.File;
67
68 import java.util.ArrayList;
69 import java.util.HashMap;
70 import java.util.Iterator;
71 import java.util.LinkedHashMap;
72 import java.util.List;
73 import java.util.Map;
74
75
83 public class GroupLocalServiceImpl extends GroupLocalServiceBaseImpl {
84
85 public GroupLocalServiceImpl() {
86 initImportLARFile();
87 }
88
89 public Group addGroup(
90 long userId, String className, long classPK, String name,
91 String description, int type, String friendlyURL, boolean active)
92 throws PortalException, SystemException {
93
94 return addGroup(
95 userId, className, classPK, GroupConstants.DEFAULT_LIVE_GROUP_ID,
96 name, description, type, friendlyURL, active);
97 }
98
99 public Group addGroup(
100 long userId, String className, long classPK, long liveGroupId,
101 String name, String description, int type, String friendlyURL,
102 boolean active)
103 throws PortalException, SystemException {
104
105
107 User user = userPersistence.findByPrimaryKey(userId);
108 className = GetterUtil.getString(className);
109 long classNameId = PortalUtil.getClassNameId(className);
110
111 long groupId = 0;
112
113 while (true) {
114 groupId = counterLocalService.increment();
115
116 User userScreenName = userPersistence.fetchByC_SN(
117 user.getCompanyId(), String.valueOf(groupId));
118
119 if (userScreenName == null) {
120 break;
121 }
122 }
123
124 friendlyURL = getFriendlyURL(groupId, classPK, friendlyURL);
125
126 long groupClassNameId = PortalUtil.getClassNameId(Group.class);
127
128 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
129 validateName(groupId, user.getCompanyId(), name);
130
131 classNameId = groupClassNameId;
132 classPK = groupId;
133 }
134 else {
135 name = String.valueOf(classPK);
136 }
137
138 validateFriendlyURL(
139 user.getCompanyId(), groupId, classNameId, classPK, friendlyURL);
140
141 Group group = groupPersistence.create(groupId);
142
143 group.setCompanyId(user.getCompanyId());
144 group.setCreatorUserId(userId);
145 group.setClassNameId(classNameId);
146 group.setClassPK(classPK);
147 group.setParentGroupId(GroupConstants.DEFAULT_PARENT_GROUP_ID);
148 group.setLiveGroupId(liveGroupId);
149 group.setName(name);
150 group.setDescription(description);
151 group.setType(type);
152 group.setFriendlyURL(friendlyURL);
153 group.setActive(active);
154
155 groupPersistence.update(group, false);
156
157
159 layoutSetLocalService.addLayoutSet(groupId, true);
160
161 layoutSetLocalService.addLayoutSet(groupId, false);
162
163 if ((classNameId == groupClassNameId) && !user.isDefaultUser()) {
164
165
167 resourceLocalService.addResources(
168 group.getCompanyId(), 0, 0, Group.class.getName(),
169 group.getGroupId(), false, false, false);
170
171
173 Role role = roleLocalService.getRole(
174 group.getCompanyId(), RoleConstants.COMMUNITY_OWNER);
175
176 userGroupRoleLocalService.addUserGroupRoles(
177 userId, groupId, new long[] {role.getRoleId()});
178
179
181 userLocalService.addGroupUsers(
182 group.getGroupId(), new long[] {userId});
183 }
184 else if (className.equals(Organization.class.getName()) &&
185 !user.isDefaultUser()) {
186
187
189 resourceLocalService.addResources(
190 group.getCompanyId(), 0, 0, Group.class.getName(),
191 group.getGroupId(), false, false, false);
192 }
193
194 return group;
195 }
196
197 public void addRoleGroups(long roleId, long[] groupIds)
198 throws SystemException {
199
200 rolePersistence.addGroups(roleId, groupIds);
201
202 PermissionCacheUtil.clearCache();
203 }
204
205 public void addUserGroups(long userId, long[] groupIds)
206 throws SystemException {
207
208 userPersistence.addGroups(userId, groupIds);
209
210 PermissionCacheUtil.clearCache();
211 }
212
213 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
214 public void checkSystemGroups(long companyId)
215 throws PortalException, SystemException {
216
217 for (Group group : groupFinder.findBySystem(companyId)) {
218 _systemGroupsMap.put(companyId + group.getName(), group);
219 }
220
221 long defaultUserId = userLocalService.getDefaultUserId(companyId);
222
223 String[] systemGroups = PortalUtil.getSystemGroups();
224
225 for (String name : systemGroups) {
226 Group group = _systemGroupsMap.get(companyId + name);
227
228 try {
229 if (group == null) {
230 group = groupPersistence.findByC_N(companyId, name);
231 }
232 }
233 catch (NoSuchGroupException nsge) {
234 String friendlyURL = null;
235
236 if (name.equals(GroupConstants.GUEST)) {
237 friendlyURL = "/guest";
238 }
239
240 group = groupLocalService.addGroup(
241 defaultUserId, null, 0, name, null,
242 GroupConstants.TYPE_COMMUNITY_OPEN, friendlyURL, true);
243 }
244
245 if (group.getName().equals(GroupConstants.GUEST)) {
246 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
247 group.getGroupId(), false);
248
249 if (layoutSet.getPageCount() == 0) {
250 addDefaultGuestPublicLayouts(group);
251 }
252 }
253
254 _systemGroupsMap.put(companyId + name, group);
255 }
256 }
257
258 public void deleteGroup(long groupId)
259 throws PortalException, SystemException {
260
261 Group group = groupPersistence.findByPrimaryKey(groupId);
262
263 if (PortalUtil.isSystemGroup(group.getName())) {
264 throw new RequiredGroupException(String.valueOf(groupId));
265 }
266
267
269 try {
270 layoutSetLocalService.deleteLayoutSet(groupId, true);
271 }
272 catch (NoSuchLayoutSetException nslse) {
273 }
274
275 try {
276 layoutSetLocalService.deleteLayoutSet(groupId, false);
277 }
278 catch (NoSuchLayoutSetException nslse) {
279 }
280
281
283 try {
284 Role role = roleLocalService.getGroupRole(
285 group.getCompanyId(), groupId);
286
287 roleLocalService.deleteRole(role.getRoleId());
288 }
289 catch (NoSuchRoleException nsre) {
290 }
291
292
294 userGroupRoleLocalService.deleteUserGroupRolesByGroupId(groupId);
295
296
298 membershipRequestLocalService.deleteMembershipRequests(
299 group.getGroupId());
300
301
303 unscheduleStaging(group);
304
305 if (group.hasStagingGroup()) {
306 deleteGroup(group.getStagingGroup().getGroupId());
307 }
308
309
311 blogsEntryLocalService.deleteEntries(groupId);
312 blogsStatsUserLocalService.deleteStatsUserByGroupId(groupId);
313
314
316 bookmarksFolderLocalService.deleteFolders(groupId);
317
318
320 calEventLocalService.deleteEvents(groupId);
321
322
324 dlFolderLocalService.deleteFolders(groupId);
325
326
328 igFolderLocalService.deleteFolders(groupId);
329
330
332 journalArticleLocalService.deleteArticles(groupId);
333 journalTemplateLocalService.deleteTemplates(groupId);
334 journalStructureLocalService.deleteStructures(groupId);
335
336
338 mbBanLocalService.deleteBansByGroupId(groupId);
339 mbCategoryLocalService.deleteCategories(groupId);
340 mbStatsUserLocalService.deleteStatsUsersByGroupId(groupId);
341
342
344 pollsQuestionLocalService.deleteQuestions(groupId);
345
346
348 shoppingCartLocalService.deleteGroupCarts(groupId);
349 shoppingCategoryLocalService.deleteCategories(groupId);
350 shoppingCouponLocalService.deleteCoupons(groupId);
351 shoppingOrderLocalService.deleteOrders(groupId);
352
353
355 scFrameworkVersionLocalService.deleteFrameworkVersions(groupId);
356 scProductEntryLocalService.deleteProductEntries(groupId);
357
358
360 wikiNodeLocalService.deleteNodes(groupId);
361
362
364 Iterator<Resource> itr = resourceFinder.findByC_P(
365 group.getCompanyId(), String.valueOf(groupId)).iterator();
366
367 while (itr.hasNext()) {
368 Resource resource = itr.next();
369
370 resourceLocalService.deleteResource(resource);
371 }
372
373 if (!group.isStagingGroup() &&
374 (group.isCommunity() || group.isOrganization())) {
375
376 resourceLocalService.deleteResource(
377 group.getCompanyId(), Group.class.getName(),
378 ResourceConstants.SCOPE_INDIVIDUAL, group.getGroupId());
379 }
380
381
383 groupPersistence.remove(group);
384
385
387 PermissionCacheUtil.clearCache();
388 }
389
390 public List<Group> getCompanyGroups(long companyId, int start, int end)
391 throws SystemException {
392
393 return groupPersistence.findByCompanyId(companyId, start, end);
394 }
395
396 public int getCompanyGroupsCount(long companyId) throws SystemException {
397 return groupPersistence.countByCompanyId(companyId);
398 }
399
400 public Group getFriendlyURLGroup(long companyId, String friendlyURL)
401 throws PortalException, SystemException {
402
403 if (Validator.isNull(friendlyURL)) {
404 throw new NoSuchGroupException();
405 }
406
407 friendlyURL = getFriendlyURL(friendlyURL);
408
409 return groupPersistence.findByC_F(companyId, friendlyURL);
410 }
411
412 public Group getGroup(long groupId)
413 throws PortalException, SystemException {
414
415 return groupPersistence.findByPrimaryKey(groupId);
416 }
417
418 public Group getGroup(long companyId, String name)
419 throws PortalException, SystemException {
420
421 Group group = _systemGroupsMap.get(companyId + name);
422
423 if (group != null) {
424 return group;
425 }
426
427 return groupPersistence.findByC_N(companyId, name);
428 }
429
430 public List<Group> getNoLayoutsGroups(
431 String className, boolean privateLayout, int start, int end)
432 throws SystemException {
433
434 long classNameId = PortalUtil.getClassNameId(className);
435
436 return groupFinder.findByNoLayouts(
437 classNameId, privateLayout, start, end);
438 }
439
440 public List<Group> getNullFriendlyURLGroups() throws SystemException {
441 return groupFinder.findByNullFriendlyURL();
442 }
443
444 public Group getOrganizationGroup(long companyId, long organizationId)
445 throws PortalException, SystemException {
446
447 long classNameId = PortalUtil.getClassNameId(Organization.class);
448
449 return groupPersistence.findByC_C_C(
450 companyId, classNameId, organizationId);
451 }
452
453 public List<Group> getOrganizationsGroups(
454 List<Organization> organizations) {
455
456 List<Group> organizationGroups = new ArrayList<Group>();
457
458 for (int i = 0; i < organizations.size(); i++) {
459 Organization organization = organizations.get(i);
460
461 Group group = organization.getGroup();
462
463 organizationGroups.add(group);
464 }
465
466 return organizationGroups;
467 }
468
469 public List<Group> getRoleGroups(long roleId) throws SystemException {
470 return rolePersistence.getGroups(roleId);
471 }
472
473 public Group getStagingGroup(long liveGroupId)
474 throws PortalException, SystemException {
475
476 return groupPersistence.findByLiveGroupId(liveGroupId);
477 }
478
479 public Group getUserGroup(long companyId, long userId)
480 throws PortalException, SystemException {
481
482 long classNameId = PortalUtil.getClassNameId(User.class);
483
484 return groupPersistence.findByC_C_C(companyId, classNameId, userId);
485 }
486
487 public Group getUserGroupGroup(long companyId, long userGroupId)
488 throws PortalException, SystemException {
489
490 long classNameId = PortalUtil.getClassNameId(UserGroup.class);
491
492 return groupPersistence.findByC_C_C(
493 companyId, classNameId, userGroupId);
494 }
495
496 public List<Group> getUserGroups(long userId)
497 throws PortalException, SystemException {
498
499 return getUserGroups(userId, false);
500 }
501
502 public List<Group> getUserGroups(long userId, boolean inherit)
503 throws PortalException, SystemException {
504
505 return getUserGroups(
506 userId, inherit, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
507 }
508
509 public List<Group> getUserGroups(long userId, int start, int end)
510 throws PortalException, SystemException {
511
512 return getUserGroups(userId, false, start, end);
513 }
514
515 public List<Group> getUserGroups(
516 long userId, boolean inherit, int start, int end)
517 throws PortalException, SystemException {
518
519 if (inherit) {
520 User user = userPersistence.findByPrimaryKey(userId);
521
522 LinkedHashMap<String, Object> groupParams =
523 new LinkedHashMap<String, Object>();
524
525 groupParams.put("usersGroups", new Long(userId));
526
527 return search(
528 user.getCompanyId(), null, null, groupParams, start, end);
529 }
530 else {
531 return userPersistence.getGroups(userId);
532 }
533 }
534
535 public List<Group> getUserGroupsGroups(List<UserGroup> userGroups) {
536 List<Group> userGroupGroups = new ArrayList<Group>();
537
538 for (int i = 0; i < userGroups.size(); i++) {
539 UserGroup userGroup = userGroups.get(i);
540
541 Group group = userGroup.getGroup();
542
543 userGroupGroups.add(group);
544 }
545
546 return userGroupGroups;
547 }
548
549 public boolean hasRoleGroup(long roleId, long groupId)
550 throws SystemException {
551
552 return rolePersistence.containsGroup(roleId, groupId);
553 }
554
555 public boolean hasStagingGroup(long liveGroupId) throws SystemException {
556 if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
557 return true;
558 }
559 else {
560 return false;
561 }
562 }
563
564 public boolean hasUserGroup(long userId, long groupId)
565 throws SystemException {
566
567 if (groupFinder.countByG_U(groupId, userId) > 0) {
568 return true;
569 }
570 else {
571 return false;
572 }
573 }
574
575 public List<Group> search(
576 long companyId, String name, String description,
577 LinkedHashMap<String, Object> params, int start, int end)
578 throws SystemException {
579
580 return search(companyId, name, description, params, start, end, null);
581 }
582
583 public List<Group> search(
584 long companyId, String name, String description,
585 LinkedHashMap<String, Object> params, int start, int end,
586 OrderByComparator obc)
587 throws SystemException {
588
589 if (obc == null) {
590 obc = new GroupNameComparator(true);
591 }
592
593 return groupFinder.findByC_N_D(
594 companyId, name, description, params, start, end, obc);
595 }
596
597 public int searchCount(
598 long companyId, String name, String description,
599 LinkedHashMap<String, Object> params)
600 throws SystemException {
601
602 return groupFinder.countByC_N_D(companyId, name, description, params);
603 }
604
605 public void setRoleGroups(long roleId, long[] groupIds)
606 throws SystemException {
607
608 rolePersistence.setGroups(roleId, groupIds);
609
610 PermissionCacheUtil.clearCache();
611 }
612
613 public void unsetRoleGroups(long roleId, long[] groupIds)
614 throws SystemException {
615
616 rolePersistence.removeGroups(roleId, groupIds);
617
618 PermissionCacheUtil.clearCache();
619 }
620
621 public void unsetUserGroups(long userId, long[] groupIds)
622 throws SystemException {
623
624 userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
625
626 userPersistence.removeGroups(userId, groupIds);
627
628 PermissionCacheUtil.clearCache();
629 }
630
631 public Group updateFriendlyURL(long groupId, String friendlyURL)
632 throws PortalException, SystemException {
633
634 Group group = groupPersistence.findByPrimaryKey(groupId);
635
636 if (group.isUser()) {
637 User user = userPersistence.findByPrimaryKey(group.getClassPK());
638
639 friendlyURL = StringPool.SLASH + user.getScreenName();
640
641 if (group.getFriendlyURL().equals(friendlyURL)) {
642 return group;
643 }
644 }
645
646 friendlyURL = getFriendlyURL(groupId, group.getClassPK(), friendlyURL);
647
648 validateFriendlyURL(
649 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
650 group.getClassPK(), friendlyURL);
651
652 group.setFriendlyURL(friendlyURL);
653
654 groupPersistence.update(group, false);
655
656 return group;
657 }
658
659 public Group updateGroup(
660 long groupId, String name, String description, int type,
661 String friendlyURL, boolean active)
662 throws PortalException, SystemException {
663
664 Group group = groupPersistence.findByPrimaryKey(groupId);
665
666 String className = group.getClassName();
667 long classNameId = group.getClassNameId();
668 long classPK = group.getClassPK();
669 friendlyURL = getFriendlyURL(groupId, classPK, friendlyURL);
670
671 if ((classNameId <= 0) || className.equals(Group.class.getName())) {
672 validateName(group.getGroupId(), group.getCompanyId(), name);
673 }
674 else {
675 name = String.valueOf(classPK);
676 }
677
678 if (PortalUtil.isSystemGroup(group.getName()) &&
679 !group.getName().equals(name)) {
680
681 throw new RequiredGroupException();
682 }
683
684 validateFriendlyURL(
685 group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
686 group.getClassPK(), friendlyURL);
687
688 group.setName(name);
689 group.setDescription(description);
690 group.setType(type);
691 group.setFriendlyURL(friendlyURL);
692 group.setActive(active);
693
694 groupPersistence.update(group, false);
695
696 return group;
697 }
698
699 public Group updateGroup(long groupId, String typeSettings)
700 throws PortalException, SystemException {
701
702 Group group = groupPersistence.findByPrimaryKey(groupId);
703
704 group.setTypeSettings(typeSettings);
705
706 groupPersistence.update(group, false);
707
708 return group;
709 }
710
711 public Group updateWorkflow(
712 long groupId, boolean workflowEnabled, int workflowStages,
713 String workflowRoleNames)
714 throws PortalException, SystemException {
715
716 Group group = groupPersistence.findByPrimaryKey(groupId);
717
718 UnicodeProperties props = group.getTypeSettingsProperties();
719
720 props.setProperty("workflowEnabled", String.valueOf(workflowEnabled));
721
722 if (workflowEnabled) {
723 if (workflowStages < PropsValues.TASKS_DEFAULT_STAGES) {
724 workflowStages = PropsValues.TASKS_DEFAULT_STAGES;
725 }
726
727 if (Validator.isNull(workflowRoleNames)) {
728 workflowRoleNames = PropsValues.TASKS_DEFAULT_ROLE_NAMES;
729 }
730
731 props.setProperty("workflowStages", String.valueOf(workflowStages));
732 props.setProperty("workflowRoleNames", workflowRoleNames);
733 }
734
735 group.setTypeSettings(group.getTypeSettings());
736
737 groupPersistence.update(group, false);
738
739 if (!workflowEnabled) {
740 tasksProposalLocalService.deleteProposals(groupId);
741 }
742
743 return group;
744 }
745
746 protected void addDefaultGuestPublicLayoutByProperties(Group group)
747 throws PortalException, SystemException {
748
749 long defaultUserId = userLocalService.getDefaultUserId(
750 group.getCompanyId());
751 String friendlyURL = getFriendlyURL(
752 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
753
754 Layout layout = layoutLocalService.addLayout(
755 defaultUserId, group.getGroupId(), false,
756 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
757 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
758 StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL);
759
760 LayoutTypePortlet layoutTypePortlet =
761 (LayoutTypePortlet)layout.getLayoutType();
762
763 layoutTypePortlet.setLayoutTemplateId(
764 0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
765
766 for (int i = 0; i < 10; i++) {
767 String columnId = "column-" + i;
768 String portletIds = PropsUtil.get(
769 PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_COLUMN + i);
770
771 layoutTypePortlet.addPortletIds(
772 0, StringUtil.split(portletIds), columnId, false);
773 }
774
775 layoutLocalService.updateLayout(
776 layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
777 layout.getTypeSettings());
778
779 boolean updateLayoutSet = false;
780
781 LayoutSet layoutSet = layout.getLayoutSet();
782
783 if (Validator.isNotNull(
784 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
785
786 layoutSet.setThemeId(
787 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
788
789 updateLayoutSet = true;
790 }
791
792 if (Validator.isNotNull(
793 PropsValues.
794 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
795
796 layoutSet.setColorSchemeId(
797 PropsValues.
798 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
799
800 updateLayoutSet = true;
801 }
802
803 if (Validator.isNotNull(
804 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
805
806 layoutSet.setWapThemeId(
807 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
808
809 updateLayoutSet = true;
810 }
811
812 if (Validator.isNotNull(
813 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
814
815 layoutSet.setWapColorSchemeId(
816 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
817
818 updateLayoutSet = true;
819 }
820
821 if (updateLayoutSet) {
822 layoutSetLocalService.updateLayoutSet(layoutSet);
823 }
824 }
825
826 protected void addDefaultGuestPublicLayouts(Group group)
827 throws PortalException, SystemException {
828
829 if (publicLARFile != null) {
830 addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
831 }
832 else {
833 addDefaultGuestPublicLayoutByProperties(group);
834 }
835 }
836
837 protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
838 throws PortalException, SystemException {
839
840 long defaultUserId = userLocalService.getDefaultUserId(
841 group.getCompanyId());
842
843 Map<String, String[]> parameterMap = new HashMap<String, String[]>();
844
845 parameterMap.put(
846 PortletDataHandlerKeys.PERMISSIONS,
847 new String[] {Boolean.TRUE.toString()});
848 parameterMap.put(
849 PortletDataHandlerKeys.PORTLET_DATA,
850 new String[] {Boolean.TRUE.toString()});
851 parameterMap.put(
852 PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
853 new String[] {Boolean.TRUE.toString()});
854 parameterMap.put(
855 PortletDataHandlerKeys.PORTLET_SETUP,
856 new String[] {Boolean.TRUE.toString()});
857 parameterMap.put(
858 PortletDataHandlerKeys.USER_PERMISSIONS,
859 new String[] {Boolean.FALSE.toString()});
860
861 layoutLocalService.importLayouts(
862 defaultUserId, group.getGroupId(), false, parameterMap, larFile);
863 }
864
865 protected String getFriendlyURL(String friendlyURL) {
866 return FriendlyURLNormalizer.normalize(friendlyURL);
867 }
868
869 protected String getFriendlyURL(
870 long groupId, long classPK, String friendlyURL) {
871
872 friendlyURL = getFriendlyURL(friendlyURL);
873
874 if (Validator.isNull(friendlyURL)) {
875 if (classPK > 0) {
876 friendlyURL = StringPool.SLASH + classPK;
877 }
878 else {
879 friendlyURL = StringPool.SLASH + groupId;
880 }
881 }
882
883 return friendlyURL;
884 }
885
886 protected void initImportLARFile() {
887 String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
888
889 if (_log.isDebugEnabled()) {
890 _log.debug("Reading public LAR file " + publicLARFileName);
891 }
892
893 if (Validator.isNotNull(publicLARFileName)) {
894 publicLARFile = new File(publicLARFileName);
895
896 if (!publicLARFile.exists()) {
897 _log.error(
898 "Public LAR file " + publicLARFile + " does not exist");
899
900 publicLARFile = null;
901 }
902 else {
903 if (_log.isDebugEnabled()) {
904 _log.debug("Using public LAR file " + publicLARFileName);
905 }
906 }
907 }
908 }
909
910 protected void unscheduleStaging(Group group) {
911 try {
912
913
915 String groupName = StagingUtil.getSchedulerGroupName(
916 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
917
918 List<SchedulerRequest> schedulerRequests =
919 SchedulerEngineUtil.getScheduledJobs(groupName);
920
921 for (SchedulerRequest schedulerRequest : schedulerRequests) {
922 SchedulerEngineUtil.unschedule(
923 schedulerRequest.getJobName(), groupName);
924 }
925
926 long liveGroupId = 0;
927 long stagingGroupId = 0;
928
929 if (group.isStagingGroup()) {
930 liveGroupId = group.getLiveGroupId();
931
932 stagingGroupId = group.getGroupId();
933 }
934 else if (group.hasStagingGroup()) {
935 liveGroupId = group.getGroupId();
936
937 stagingGroupId = group.getStagingGroup().getGroupId();
938 }
939
940 if ((liveGroupId != 0) && (stagingGroupId != 0)) {
941
942
944 groupName = StagingUtil.getSchedulerGroupName(
945 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
946
947 schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
948 groupName);
949
950 for (SchedulerRequest schedulerRequest : schedulerRequests) {
951 SchedulerEngineUtil.unschedule(
952 schedulerRequest.getJobName(), groupName);
953 }
954
955
957 groupName = StagingUtil.getSchedulerGroupName(
958 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
959
960 schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
961 groupName);
962
963 for (SchedulerRequest schedulerRequest : schedulerRequests) {
964 SchedulerEngineUtil.unschedule(
965 schedulerRequest.getJobName(), groupName);
966 }
967 }
968 }
969 catch (Exception e) {
970 _log.error(
971 "Unable to unschedule events for group: " + group.getGroupId());
972 }
973 }
974
975 protected void validateFriendlyURL(
976 long companyId, long groupId, long classNameId, long classPK,
977 String friendlyURL)
978 throws PortalException, SystemException {
979
980 Company company = companyPersistence.findByPrimaryKey(companyId);
981
982 if (company.isSystem()) {
983 return;
984 }
985
986 if (Validator.isNull(friendlyURL)) {
987 return;
988 }
989
990 int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
991
992 if (exceptionType != -1) {
993 throw new GroupFriendlyURLException(exceptionType);
994 }
995
996 Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
997
998 if ((group != null) && (group.getGroupId() != groupId)) {
999 throw new GroupFriendlyURLException(
1000 GroupFriendlyURLException.DUPLICATE);
1001 }
1002
1003 String groupIdFriendlyURL = friendlyURL.substring(1);
1004
1005 if (Validator.isNumber(groupIdFriendlyURL)) {
1006 long groupClassNameId = PortalUtil.getClassNameId(Group.class);
1007
1008 if (((classNameId != groupClassNameId) &&
1009 (!groupIdFriendlyURL.equals(String.valueOf(classPK))) &&
1010 (!PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC)) ||
1011 ((classNameId == groupClassNameId) &&
1012 (!groupIdFriendlyURL.equals(String.valueOf(groupId))))) {
1013
1014 GroupFriendlyURLException gfurle =
1015 new GroupFriendlyURLException(
1016 GroupFriendlyURLException.POSSIBLE_DUPLICATE);
1017
1018 gfurle.setKeywordConflict(groupIdFriendlyURL);
1019
1020 throw gfurle;
1021 }
1022 }
1023
1024 String screenName = friendlyURL.substring(1);
1025
1026 User user = userPersistence.fetchByC_SN(companyId, screenName);
1027
1028 if (user != null) {
1029 long userClassNameId = PortalUtil.getClassNameId(User.class);
1030
1031 if ((classNameId == userClassNameId) &&
1032 (classPK == user.getUserId())) {
1033 }
1034 else {
1035 throw new GroupFriendlyURLException(
1036 GroupFriendlyURLException.DUPLICATE);
1037 }
1038 }
1039
1040 if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
1041 throw new GroupFriendlyURLException(
1042 GroupFriendlyURLException.TOO_DEEP);
1043 }
1044 }
1045
1046 protected void validateName(long groupId, long companyId, String name)
1047 throws PortalException, SystemException {
1048
1049 if ((Validator.isNull(name)) || (Validator.isNumber(name)) ||
1050 (name.indexOf(StringPool.COMMA) != -1) ||
1051 (name.indexOf(StringPool.STAR) != -1)) {
1052
1053 throw new GroupNameException();
1054 }
1055
1056 try {
1057 Group group = groupFinder.findByC_N(companyId, name);
1058
1059 if ((groupId <= 0) || (group.getGroupId() != groupId)) {
1060 throw new DuplicateGroupException();
1061 }
1062 }
1063 catch (NoSuchGroupException nsge) {
1064 }
1065 }
1066
1067 protected File publicLARFile;
1068
1069 private static Log _log = LogFactoryUtil.getLog(
1070 GroupLocalServiceImpl.class);
1071
1072 private Map<String, Group> _systemGroupsMap = new HashMap<String, Group>();
1073
1074}