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.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  /**
83   * <a href="GroupLocalServiceImpl.java.html"><b><i>View Source</i></b></a>
84   *
85   * @author Brian Wing Shun Chan
86   * @author Alexander Chow
87   * @author Bruno Farache
88   *
89   */
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         // Group
113 
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         // Layout sets
146 
147         layoutSetLocalService.addLayoutSet(groupId, true);
148 
149         layoutSetLocalService.addLayoutSet(groupId, false);
150 
151         if ((classNameId <= 0) && (classPK <= 0) && !user.isDefaultUser()) {
152 
153             // Resources
154 
155             resourceLocalService.addResources(
156                 group.getCompanyId(), 0, 0, Group.class.getName(),
157                 group.getGroupId(), false, false, false);
158 
159             // Community roles
160 
161             Role role = roleLocalService.getRole(
162                 group.getCompanyId(), RoleConstants.COMMUNITY_OWNER);
163 
164             userGroupRoleLocalService.addUserGroupRoles(
165                 userId, groupId, new long[] {role.getRoleId()});
166 
167             // User
168 
169             userLocalService.addGroupUsers(
170                 group.getGroupId(), new long[] {userId});
171         }
172         else if (className.equals(Organization.class.getName()) &&
173                  !user.isDefaultUser()) {
174 
175             // Resources
176 
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         // Layout sets
259 
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         // Role
273 
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         // Group roles
284 
285         userGroupRoleLocalService.deleteUserGroupRolesByGroupId(groupId);
286 
287         // Membership requests
288 
289         membershipRequestLocalService.deleteMembershipRequests(
290             group.getGroupId());
291 
292         // Scheduled staging
293 
294         unscheduleStaging(group);
295 
296         // Blogs
297 
298         blogsEntryLocalService.deleteEntries(groupId);
299         blogsStatsUserLocalService.deleteStatsUserByGroupId(groupId);
300 
301         // Bookmarks
302 
303         bookmarksFolderLocalService.deleteFolders(groupId);
304 
305         // Calendar
306 
307         calEventLocalService.deleteEvents(groupId);
308 
309         // Document library
310 
311         dlFolderLocalService.deleteFolders(groupId);
312 
313         // Image gallery
314 
315         igFolderLocalService.deleteFolders(groupId);
316 
317         // Journal
318 
319         journalArticleLocalService.deleteArticles(groupId);
320         journalTemplateLocalService.deleteTemplates(groupId);
321         journalStructureLocalService.deleteStructures(groupId);
322 
323         // Message boards
324 
325         mbBanLocalService.deleteBansByGroupId(groupId);
326         mbCategoryLocalService.deleteCategories(groupId);
327         mbStatsUserLocalService.deleteStatsUserByGroupId(groupId);
328 
329         // Polls
330 
331         pollsQuestionLocalService.deleteQuestions(groupId);
332 
333         // Shopping
334 
335         shoppingCartLocalService.deleteGroupCarts(groupId);
336         shoppingCategoryLocalService.deleteCategories(groupId);
337         shoppingCouponLocalService.deleteCoupons(groupId);
338         shoppingOrderLocalService.deleteOrders(groupId);
339 
340         // Software catalog
341 
342         scFrameworkVersionLocalService.deleteFrameworkVersions(groupId);
343         scProductEntryLocalService.deleteProductEntries(groupId);
344 
345         // Wiki
346 
347         wikiNodeLocalService.deleteNodes(groupId);
348 
349         // Resources
350 
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         // Group
369 
370         groupPersistence.remove(group);
371 
372         // Permission cache
373 
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             // Remote publishing
839 
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                 // Publish to live
868 
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                 // Copy from live
881 
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 }