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