1   /**
2    * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
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  /**
79   * <a href="GroupLocalServiceImpl.java.html"><b><i>View Source</i></b></a>
80   *
81   * @author Brian Wing Shun Chan
82   * @author Alexander Chow
83   *
84   */
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         // Group
108 
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         // Layout sets
141 
142         layoutSetLocalService.addLayoutSet(groupId, true);
143 
144         layoutSetLocalService.addLayoutSet(groupId, false);
145 
146         if ((classNameId <= 0) && (classPK <= 0) && !user.isDefaultUser()) {
147 
148             // Resources
149 
150             resourceLocalService.addResources(
151                 group.getCompanyId(), 0, 0, Group.class.getName(),
152                 group.getGroupId(), false, false, false);
153 
154             // Community roles
155 
156             Role role = roleLocalService.getRole(
157                 group.getCompanyId(), RoleImpl.COMMUNITY_OWNER);
158 
159             userGroupRoleLocalService.addUserGroupRoles(
160                 userId, groupId, new long[] {role.getRoleId()});
161 
162             // User
163 
164             userLocalService.addGroupUsers(
165                 group.getGroupId(), new long[] {userId});
166         }
167         else if (className.equals(Organization.class.getName()) &&
168                  !user.isDefaultUser()) {
169 
170             // Resources
171 
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         // Layout sets
254 
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         // Role
268 
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         // Group roles
279 
280         userGroupRoleLocalService.deleteUserGroupRolesByGroupId(groupId);
281 
282         // Membership requests
283 
284         membershipRequestLocalService.deleteMembershipRequests(
285             group.getGroupId());
286 
287         // Blogs
288 
289         blogsEntryLocalService.deleteEntries(groupId);
290         blogsStatsUserLocalService.deleteStatsUserByGroupId(groupId);
291 
292         // Bookmarks
293 
294         bookmarksFolderLocalService.deleteFolders(groupId);
295 
296         // Calendar
297 
298         calEventLocalService.deleteEvents(groupId);
299 
300         // Document library
301 
302         dlFolderLocalService.deleteFolders(groupId);
303 
304         // Image gallery
305 
306         igFolderLocalService.deleteFolders(groupId);
307 
308         // Journal
309 
310         journalArticleLocalService.deleteArticles(groupId);
311         journalTemplateLocalService.deleteTemplates(groupId);
312         journalStructureLocalService.deleteStructures(groupId);
313 
314         // Message boards
315 
316         mbBanLocalService.deleteBansByGroupId(groupId);
317         mbCategoryLocalService.deleteCategories(groupId);
318         mbStatsUserLocalService.deleteStatsUserByGroupId(groupId);
319 
320         // Polls
321 
322         pollsQuestionLocalService.deleteQuestions(groupId);
323 
324         // Shopping
325 
326         shoppingCartLocalService.deleteGroupCarts(groupId);
327         shoppingCategoryLocalService.deleteCategories(groupId);
328         shoppingCouponLocalService.deleteCoupons(groupId);
329         shoppingOrderLocalService.deleteOrders(groupId);
330 
331         // Software catalog
332 
333         scFrameworkVersionLocalService.deleteFrameworkVersions(groupId);
334         scProductEntryLocalService.deleteProductEntries(groupId);
335 
336         // Wiki
337 
338         wikiNodeLocalService.deleteNodes(groupId);
339 
340         // Resources
341 
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         // Group
360 
361         groupPersistence.remove(groupId);
362 
363         // Permission cache
364 
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 }