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