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