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