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