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.messaging.DestinationNames;
35 import com.liferay.portal.kernel.scheduler.SchedulerEngineUtil;
36 import com.liferay.portal.kernel.scheduler.messaging.SchedulerRequest;
37 import com.liferay.portal.kernel.util.GetterUtil;
38 import com.liferay.portal.kernel.util.OrderByComparator;
39 import com.liferay.portal.kernel.util.StringPool;
40 import com.liferay.portal.kernel.util.StringUtil;
41 import com.liferay.portal.kernel.util.UnicodeProperties;
42 import com.liferay.portal.kernel.util.Validator;
43 import com.liferay.portal.lar.PortletDataHandlerKeys;
44 import com.liferay.portal.model.Group;
45 import com.liferay.portal.model.GroupConstants;
46 import com.liferay.portal.model.Layout;
47 import com.liferay.portal.model.LayoutConstants;
48 import com.liferay.portal.model.LayoutSet;
49 import com.liferay.portal.model.LayoutTypePortlet;
50 import com.liferay.portal.model.Organization;
51 import com.liferay.portal.model.Resource;
52 import com.liferay.portal.model.ResourceConstants;
53 import com.liferay.portal.model.Role;
54 import com.liferay.portal.model.RoleConstants;
55 import com.liferay.portal.model.User;
56 import com.liferay.portal.model.UserGroup;
57 import com.liferay.portal.model.impl.LayoutImpl;
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, 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 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(GroupConstants.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(), RoleConstants.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(), RoleConstants.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(GroupConstants.GUEST)) {
230 friendlyURL = "/guest";
231 }
232
233 group = addGroup(
234 defaultUserId, null, 0, systemGroups[i], null,
235 GroupConstants.TYPE_COMMUNITY_OPEN, friendlyURL, true);
236 }
237
238 if (group.getName().equals(GroupConstants.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(group);
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 hasStagingGroup(long liveGroupId) throws SystemException {
482 if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
483 return true;
484 }
485 else {
486 return false;
487 }
488 }
489
490 public boolean hasUserGroup(long userId, long groupId)
491 throws SystemException {
492
493 if (groupFinder.countByG_U(groupId, userId) > 0) {
494 return true;
495 }
496 else {
497 return false;
498 }
499 }
500
501 public List<Group> search(
502 long companyId, String name, String description,
503 LinkedHashMap<String, Object> params, int start, int end)
504 throws SystemException {
505
506 return groupFinder.findByC_N_D(
507 companyId, name, description, params, start, end, null);
508 }
509
510 public List<Group> search(
511 long companyId, String name, String description,
512 LinkedHashMap<String, Object> params, int start, int end,
513 OrderByComparator obc)
514 throws SystemException {
515
516 if (obc == null) {
517 obc = new GroupNameComparator(true);
518 }
519
520 return groupFinder.findByC_N_D(
521 companyId, name, description, params, start, end, obc);
522 }
523
524 public int searchCount(
525 long companyId, String name, String description,
526 LinkedHashMap<String, Object> params)
527 throws SystemException {
528
529 return groupFinder.countByC_N_D(companyId, name, description, params);
530 }
531
532 public void setRoleGroups(long roleId, long[] groupIds)
533 throws SystemException {
534
535 rolePersistence.setGroups(roleId, groupIds);
536
537 PermissionCacheUtil.clearCache();
538 }
539
540 public void unsetRoleGroups(long roleId, long[] groupIds)
541 throws SystemException {
542
543 rolePersistence.removeGroups(roleId, groupIds);
544
545 PermissionCacheUtil.clearCache();
546 }
547
548 public void unsetUserGroups(long userId, long[] groupIds)
549 throws SystemException {
550
551 userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
552
553 userPersistence.removeGroups(userId, groupIds);
554
555 PermissionCacheUtil.clearCache();
556 }
557
558 public Group updateFriendlyURL(long groupId, String friendlyURL)
559 throws PortalException, SystemException {
560
561 Group group = groupPersistence.findByPrimaryKey(groupId);
562
563 if (group.isUser()) {
564 User user = userPersistence.findByPrimaryKey(group.getClassPK());
565
566 friendlyURL = StringPool.SLASH + user.getScreenName();
567
568 if (group.getFriendlyURL().equals(friendlyURL)) {
569 return group;
570 }
571 }
572
573 friendlyURL = getFriendlyURL(groupId, group.getClassPK(), friendlyURL);
574
575 validateFriendlyURL(
576 group.getGroupId(), group.getCompanyId(), group.getClassNameId(),
577 group.getClassPK(), friendlyURL);
578
579 group.setFriendlyURL(friendlyURL);
580
581 groupPersistence.update(group, false);
582
583 return group;
584 }
585
586 public Group updateGroup(
587 long groupId, String name, String description, int type,
588 String friendlyURL, boolean active)
589 throws PortalException, SystemException {
590
591 Group group = groupPersistence.findByPrimaryKey(groupId);
592
593 long classNameId = group.getClassNameId();
594 long classPK = group.getClassPK();
595 friendlyURL = getFriendlyURL(groupId, classPK, friendlyURL);
596
597 if ((classNameId <= 0) || (classPK <= 0)) {
598 validateName(group.getGroupId(), group.getCompanyId(), name);
599 }
600
601 if (PortalUtil.isSystemGroup(group.getName()) &&
602 !group.getName().equals(name)) {
603
604 throw new RequiredGroupException();
605 }
606
607 validateFriendlyURL(
608 group.getGroupId(), group.getCompanyId(), group.getClassNameId(),
609 group.getClassPK(), friendlyURL);
610
611 group.setName(name);
612 group.setDescription(description);
613 group.setType(type);
614 group.setFriendlyURL(friendlyURL);
615 group.setActive(active);
616
617 groupPersistence.update(group, false);
618
619 return group;
620 }
621
622 public Group updateGroup(long groupId, String typeSettings)
623 throws PortalException, SystemException {
624
625 Group group = groupPersistence.findByPrimaryKey(groupId);
626
627 group.setTypeSettings(typeSettings);
628
629 groupPersistence.update(group, false);
630
631 return group;
632 }
633
634 public Group updateWorkflow(
635 long groupId, boolean workflowEnabled, int workflowStages,
636 String workflowRoleNames)
637 throws PortalException, SystemException {
638
639 Group group = groupPersistence.findByPrimaryKey(groupId);
640
641 UnicodeProperties props = group.getTypeSettingsProperties();
642
643 props.setProperty("workflowEnabled", String.valueOf(workflowEnabled));
644
645 if (workflowEnabled) {
646 if (workflowStages < PropsValues.TASKS_DEFAULT_STAGES) {
647 workflowStages = PropsValues.TASKS_DEFAULT_STAGES;
648 }
649
650 if (Validator.isNull(workflowRoleNames)) {
651 workflowRoleNames = PropsValues.TASKS_DEFAULT_ROLE_NAMES;
652 }
653
654 props.setProperty("workflowStages", String.valueOf(workflowStages));
655 props.setProperty("workflowRoleNames", workflowRoleNames);
656 }
657
658 group.setTypeSettings(group.getTypeSettings());
659
660 groupPersistence.update(group, false);
661
662 if (!workflowEnabled) {
663 tasksProposalLocalService.deleteProposals(groupId);
664 }
665
666 return group;
667 }
668
669 protected void addDefaultGuestPublicLayoutByProperties(Group group)
670 throws PortalException, SystemException {
671
672 long defaultUserId = userLocalService.getDefaultUserId(
673 group.getCompanyId());
674 String friendlyURL = getFriendlyURL(
675 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
676
677 Layout layout = layoutLocalService.addLayout(
678 defaultUserId, group.getGroupId(), false,
679 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
680 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
681 StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL);
682
683 LayoutTypePortlet layoutTypePortlet =
684 (LayoutTypePortlet)layout.getLayoutType();
685
686 layoutTypePortlet.setLayoutTemplateId(
687 0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
688
689 for (int i = 0; i < 10; i++) {
690 String columnId = "column-" + i;
691 String portletIds = PropsUtil.get(
692 PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_COLUMN + i);
693
694 layoutTypePortlet.addPortletIds(
695 0, StringUtil.split(portletIds), columnId, false);
696 }
697
698 layoutLocalService.updateLayout(
699 layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
700 layout.getTypeSettings());
701
702 boolean updateLayoutSet = false;
703
704 LayoutSet layoutSet = layout.getLayoutSet();
705
706 if (Validator.isNotNull(
707 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
708
709 layoutSet.setThemeId(
710 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
711
712 updateLayoutSet = true;
713 }
714
715 if (Validator.isNotNull(
716 PropsValues.
717 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
718
719 layoutSet.setColorSchemeId(
720 PropsValues.
721 DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
722
723 updateLayoutSet = true;
724 }
725
726 if (Validator.isNotNull(
727 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
728
729 layoutSet.setWapThemeId(
730 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
731
732 updateLayoutSet = true;
733 }
734
735 if (Validator.isNotNull(
736 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
737
738 layoutSet.setWapColorSchemeId(
739 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
740
741 updateLayoutSet = true;
742 }
743
744 if (updateLayoutSet) {
745 LayoutSetLocalServiceUtil.updateLayoutSet(layoutSet);
746 }
747 }
748
749 protected void addDefaultGuestPublicLayouts(Group group)
750 throws PortalException, SystemException {
751
752 if (publicLARFile != null) {
753 addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
754 }
755 else {
756 addDefaultGuestPublicLayoutByProperties(group);
757 }
758 }
759
760 protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
761 throws PortalException, SystemException {
762
763 long defaultUserId = userLocalService.getDefaultUserId(
764 group.getCompanyId());
765
766 Map<String, String[]> parameterMap = new HashMap<String, String[]>();
767
768 parameterMap.put(
769 PortletDataHandlerKeys.PERMISSIONS,
770 new String[] {Boolean.TRUE.toString()});
771 parameterMap.put(
772 PortletDataHandlerKeys.PORTLET_DATA,
773 new String[] {Boolean.TRUE.toString()});
774 parameterMap.put(
775 PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
776 new String[] {Boolean.TRUE.toString()});
777 parameterMap.put(
778 PortletDataHandlerKeys.PORTLET_SETUP,
779 new String[] {Boolean.TRUE.toString()});
780 parameterMap.put(
781 PortletDataHandlerKeys.USER_PERMISSIONS,
782 new String[] {Boolean.FALSE.toString()});
783
784 LayoutLocalServiceUtil.importLayouts(
785 defaultUserId, group.getGroupId(), false, parameterMap, larFile);
786 }
787
788 protected String getFriendlyURL(String friendlyURL) {
789 friendlyURL = GetterUtil.getString(friendlyURL);
790
791 return Normalizer.normalizeToAscii(friendlyURL.trim().toLowerCase());
792 }
793
794 protected String getFriendlyURL(
795 long groupId, long classPK, String friendlyURL) {
796
797 friendlyURL = getFriendlyURL(friendlyURL);
798
799 if (Validator.isNull(friendlyURL)) {
800 if (classPK > 0) {
801 friendlyURL = StringPool.SLASH + classPK;
802 }
803 else {
804 friendlyURL = StringPool.SLASH + groupId;
805 }
806 }
807
808 return friendlyURL;
809 }
810
811 protected void initImportLARFile() {
812 String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
813
814 if (_log.isDebugEnabled()) {
815 _log.debug("Reading public LAR file " + publicLARFileName);
816 }
817
818 if (Validator.isNotNull(publicLARFileName)) {
819 publicLARFile = new File(publicLARFileName);
820
821 if (!publicLARFile.exists()) {
822 _log.error(
823 "Public LAR file " + publicLARFile + " does not exist");
824
825 publicLARFile = null;
826 }
827 else {
828 if (_log.isDebugEnabled()) {
829 _log.debug("Using public LAR file " + publicLARFileName);
830 }
831 }
832 }
833 }
834
835 protected void unscheduleStaging(Group group) {
836 try {
837
838
840 String groupName = StagingUtil.getSchedulerGroupName(
841 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
842
843 List<SchedulerRequest> schedulerRequests =
844 SchedulerEngineUtil.getScheduledJobs(groupName);
845
846 for (SchedulerRequest schedulerRequest : schedulerRequests) {
847 SchedulerEngineUtil.unschedule(
848 schedulerRequest.getJobName(), groupName);
849 }
850
851 long liveGroupId = 0;
852 long stagingGroupId = 0;
853
854 if (group.isStagingGroup()) {
855 liveGroupId = group.getLiveGroupId();
856
857 stagingGroupId = group.getGroupId();
858 }
859 else if (group.hasStagingGroup()) {
860 liveGroupId = group.getGroupId();
861
862 stagingGroupId = group.getStagingGroup().getGroupId();
863 }
864
865 if ((liveGroupId != 0) && (stagingGroupId != 0)) {
866
867
869 groupName = StagingUtil.getSchedulerGroupName(
870 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
871
872 schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
873 groupName);
874
875 for (SchedulerRequest schedulerRequest : schedulerRequests) {
876 SchedulerEngineUtil.unschedule(
877 schedulerRequest.getJobName(), groupName);
878 }
879
880
882 groupName = StagingUtil.getSchedulerGroupName(
883 DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
884
885 schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
886 groupName);
887
888 for (SchedulerRequest schedulerRequest : schedulerRequests) {
889 SchedulerEngineUtil.unschedule(
890 schedulerRequest.getJobName(), groupName);
891 }
892 }
893 }
894 catch (Exception e) {
895 _log.error(
896 "Unable to unschedule events for group: " + group.getGroupId());
897 }
898 }
899
900 protected void validateFriendlyURL(
901 long groupId, long companyId, long classNameId, long classPK,
902 String friendlyURL)
903 throws PortalException, SystemException {
904
905 if (Validator.isNull(friendlyURL)) {
906 return;
907 }
908
909 int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
910
911 if (exceptionType != -1) {
912 throw new GroupFriendlyURLException(exceptionType);
913 }
914
915 Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
916
917 if ((group != null) && (group.getGroupId() != groupId)) {
918 throw new GroupFriendlyURLException(
919 GroupFriendlyURLException.DUPLICATE);
920 }
921
922 String groupIdFriendlyURL = friendlyURL.substring(1);
923
924 if (Validator.isNumber(groupIdFriendlyURL)) {
925 if (((classPK > 0) &&
926 (!groupIdFriendlyURL.equals(String.valueOf(classPK)))) ||
927 ((classPK == 0) &&
928 (!groupIdFriendlyURL.equals(String.valueOf(groupId))))) {
929
930 GroupFriendlyURLException gfurle =
931 new GroupFriendlyURLException(
932 GroupFriendlyURLException.POSSIBLE_DUPLICATE);
933
934 gfurle.setKeywordConflict(groupIdFriendlyURL);
935
936 throw gfurle;
937 }
938 }
939
940 String screenName = friendlyURL.substring(1);
941
942 User user = userPersistence.fetchByC_SN(companyId, screenName);
943
944 if (user != null) {
945 long userClassNameId = PortalUtil.getClassNameId(
946 User.class.getName());
947
948 if ((classNameId == userClassNameId) &&
949 (classPK == user.getUserId())) {
950 }
951 else {
952 throw new GroupFriendlyURLException(
953 GroupFriendlyURLException.DUPLICATE);
954 }
955 }
956 }
957
958 protected void validateName(long groupId, long companyId, String name)
959 throws PortalException, SystemException {
960
961 if ((Validator.isNull(name)) || (Validator.isNumber(name)) ||
962 (name.indexOf(StringPool.COMMA) != -1) ||
963 (name.indexOf(StringPool.STAR) != -1)) {
964
965 throw new GroupNameException();
966 }
967
968 try {
969 Group group = groupFinder.findByC_N(companyId, name);
970
971 if ((groupId <= 0) || (group.getGroupId() != groupId)) {
972 throw new DuplicateGroupException();
973 }
974 }
975 catch (NoSuchGroupException nsge) {
976 }
977 }
978
979 protected File publicLARFile;
980
981 private static Log _log = LogFactory.getLog(GroupLocalServiceImpl.class);
982
983 }