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.messaging.DestinationNames;
36  import com.liferay.portal.kernel.scheduler.SchedulerEngineUtil;
37  import com.liferay.portal.kernel.scheduler.messaging.SchedulerRequest;
38  import com.liferay.portal.kernel.util.GetterUtil;
39  import com.liferay.portal.kernel.util.OrderByComparator;
40  import com.liferay.portal.kernel.util.StringPool;
41  import com.liferay.portal.kernel.util.StringUtil;
42  import com.liferay.portal.kernel.util.UnicodeProperties;
43  import com.liferay.portal.kernel.util.Validator;
44  import com.liferay.portal.model.Group;
45  import com.liferay.portal.model.Layout;
46  import com.liferay.portal.model.LayoutConstants;
47  import com.liferay.portal.model.LayoutSet;
48  import com.liferay.portal.model.LayoutTypePortlet;
49  import com.liferay.portal.model.Organization;
50  import com.liferay.portal.model.Resource;
51  import com.liferay.portal.model.ResourceConstants;
52  import com.liferay.portal.model.Role;
53  import com.liferay.portal.model.User;
54  import com.liferay.portal.model.UserGroup;
55  import com.liferay.portal.model.impl.GroupImpl;
56  import com.liferay.portal.model.impl.LayoutImpl;
57  import com.liferay.portal.model.impl.RoleImpl;
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, GroupImpl.DEFAULT_LIVE_GROUP_ID, name,
103             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(GroupImpl.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(), RoleImpl.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(), RoleImpl.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(GroupImpl.GUEST)) {
230                     friendlyURL = "/guest";
231                 }
232 
233                 group = addGroup(
234                     defaultUserId, null, 0, systemGroups[i], null,
235                     GroupImpl.TYPE_COMMUNITY_OPEN, friendlyURL, true);
236             }
237 
238             if (group.getName().equals(GroupImpl.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(groupId);
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 hasUserGroup(long userId, long groupId)
482         throws SystemException {
483 
484         if (groupFinder.countByG_U(groupId, userId) > 0) {
485             return true;
486         }
487         else {
488             return false;
489         }
490     }
491 
492     public List<Group> search(
493             long companyId, String name, String description,
494             LinkedHashMap<String, Object> params, int start, int end)
495         throws SystemException {
496 
497         return groupFinder.findByC_N_D(
498             companyId, name, description, params, start, end, null);
499     }
500 
501     public List<Group> search(
502             long companyId, String name, String description,
503             LinkedHashMap<String, Object> params, int start, int end,
504             OrderByComparator obc)
505         throws SystemException {
506 
507         if (obc == null) {
508             obc = new GroupNameComparator(true);
509         }
510 
511         return groupFinder.findByC_N_D(
512             companyId, name, description, params, start, end, obc);
513     }
514 
515     public int searchCount(
516             long companyId, String name, String description,
517             LinkedHashMap<String, Object> params)
518         throws SystemException {
519 
520         return groupFinder.countByC_N_D(companyId, name, description, params);
521     }
522 
523     public void setRoleGroups(long roleId, long[] groupIds)
524         throws SystemException {
525 
526         rolePersistence.setGroups(roleId, groupIds);
527 
528         PermissionCacheUtil.clearCache();
529     }
530 
531     public void unsetRoleGroups(long roleId, long[] groupIds)
532         throws SystemException {
533 
534         rolePersistence.removeGroups(roleId, groupIds);
535 
536         PermissionCacheUtil.clearCache();
537     }
538 
539     public void unsetUserGroups(long userId, long[] groupIds)
540         throws SystemException {
541 
542         userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
543 
544         userPersistence.removeGroups(userId, groupIds);
545 
546         PermissionCacheUtil.clearCache();
547     }
548 
549     public Group updateFriendlyURL(long groupId, String friendlyURL)
550         throws PortalException, SystemException {
551 
552         Group group = groupPersistence.findByPrimaryKey(groupId);
553 
554         if (group.isUser()) {
555             User user = userPersistence.findByPrimaryKey(group.getClassPK());
556 
557             friendlyURL = StringPool.SLASH + user.getScreenName();
558 
559             if (group.getFriendlyURL().equals(friendlyURL)) {
560                 return group;
561             }
562         }
563 
564         friendlyURL = getFriendlyURL(groupId, group.getClassPK(), friendlyURL);
565 
566         validateFriendlyURL(
567             group.getGroupId(), group.getCompanyId(), group.getClassNameId(),
568             group.getClassPK(), friendlyURL);
569 
570         group.setFriendlyURL(friendlyURL);
571 
572         groupPersistence.update(group, false);
573 
574         return group;
575     }
576 
577     public Group updateGroup(
578             long groupId, String name, String description, int type,
579             String friendlyURL, boolean active)
580         throws PortalException, SystemException {
581 
582         Group group = groupPersistence.findByPrimaryKey(groupId);
583 
584         long classNameId = group.getClassNameId();
585         long classPK = group.getClassPK();
586         friendlyURL = getFriendlyURL(groupId, classPK, friendlyURL);
587 
588         if ((classNameId <= 0) || (classPK <= 0)) {
589             validateName(group.getGroupId(), group.getCompanyId(), name);
590         }
591 
592         if (PortalUtil.isSystemGroup(group.getName()) &&
593             !group.getName().equals(name)) {
594 
595             throw new RequiredGroupException();
596         }
597 
598         validateFriendlyURL(
599             group.getGroupId(), group.getCompanyId(), group.getClassNameId(),
600             group.getClassPK(), friendlyURL);
601 
602         group.setName(name);
603         group.setDescription(description);
604         group.setType(type);
605         group.setFriendlyURL(friendlyURL);
606         group.setActive(active);
607 
608         groupPersistence.update(group, false);
609 
610         return group;
611     }
612 
613     public Group updateGroup(long groupId, String typeSettings)
614         throws PortalException, SystemException {
615 
616         Group group = groupPersistence.findByPrimaryKey(groupId);
617 
618         group.setTypeSettings(typeSettings);
619 
620         groupPersistence.update(group, false);
621 
622         return group;
623     }
624 
625     public Group updateWorkflow(
626             long groupId, boolean workflowEnabled, int workflowStages,
627             String workflowRoleNames)
628         throws PortalException, SystemException {
629 
630         Group group = groupPersistence.findByPrimaryKey(groupId);
631 
632         UnicodeProperties props = group.getTypeSettingsProperties();
633 
634         props.setProperty("workflowEnabled", String.valueOf(workflowEnabled));
635 
636         if (workflowEnabled) {
637             if (workflowStages < PropsValues.TASKS_DEFAULT_STAGES) {
638                 workflowStages = PropsValues.TASKS_DEFAULT_STAGES;
639             }
640 
641             if (Validator.isNull(workflowRoleNames)) {
642                 workflowRoleNames = PropsValues.TASKS_DEFAULT_ROLE_NAMES;
643             }
644 
645             props.setProperty("workflowStages", String.valueOf(workflowStages));
646             props.setProperty("workflowRoleNames", workflowRoleNames);
647         }
648 
649         group.setTypeSettings(group.getTypeSettings());
650 
651         groupPersistence.update(group, false);
652 
653         if (!workflowEnabled) {
654             tasksProposalLocalService.deleteProposals(groupId);
655         }
656 
657         return group;
658     }
659 
660     protected void addDefaultGuestPublicLayoutByProperties(Group group)
661         throws PortalException, SystemException {
662 
663         long defaultUserId = userLocalService.getDefaultUserId(
664             group.getCompanyId());
665         String friendlyURL = getFriendlyURL(
666             PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
667 
668         Layout layout = layoutLocalService.addLayout(
669             defaultUserId, group.getGroupId(), false,
670             LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
671             PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
672             StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL);
673 
674         LayoutTypePortlet layoutTypePortlet =
675             (LayoutTypePortlet)layout.getLayoutType();
676 
677         layoutTypePortlet.setLayoutTemplateId(
678             0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
679 
680         for (int i = 0; i < 10; i++) {
681             String columnId = "column-" + i;
682             String portletIds = PropsUtil.get(
683                 PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_COLUMN + i);
684 
685             layoutTypePortlet.addPortletIds(
686                 0, StringUtil.split(portletIds), columnId, false);
687         }
688 
689         layoutLocalService.updateLayout(
690             layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
691             layout.getTypeSettings());
692 
693         boolean updateLayoutSet = false;
694 
695         LayoutSet layoutSet = layout.getLayoutSet();
696 
697         if (Validator.isNotNull(
698                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
699 
700             layoutSet.setThemeId(
701                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
702 
703             updateLayoutSet = true;
704         }
705 
706         if (Validator.isNotNull(
707                 PropsValues.
708                     DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
709 
710             layoutSet.setColorSchemeId(
711                 PropsValues.
712                     DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
713 
714             updateLayoutSet = true;
715         }
716 
717         if (Validator.isNotNull(
718                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
719 
720             layoutSet.setWapThemeId(
721                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
722 
723             updateLayoutSet = true;
724         }
725 
726         if (Validator.isNotNull(
727                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
728 
729             layoutSet.setWapColorSchemeId(
730                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
731 
732             updateLayoutSet = true;
733         }
734 
735         if (updateLayoutSet) {
736             LayoutSetLocalServiceUtil.updateLayoutSet(layoutSet);
737         }
738     }
739 
740     protected void addDefaultGuestPublicLayouts(Group group)
741         throws PortalException, SystemException {
742 
743         if (publicLARFile != null) {
744             addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
745         }
746         else {
747             addDefaultGuestPublicLayoutByProperties(group);
748         }
749     }
750 
751     protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
752         throws PortalException, SystemException {
753 
754         long defaultUserId = userLocalService.getDefaultUserId(
755             group.getCompanyId());
756 
757         Map<String, String[]> parameterMap = new HashMap<String, String[]>();
758 
759         parameterMap.put(
760             PortletDataHandlerKeys.PERMISSIONS,
761             new String[] {Boolean.TRUE.toString()});
762         parameterMap.put(
763             PortletDataHandlerKeys.USER_PERMISSIONS,
764             new String[] {Boolean.FALSE.toString()});
765         parameterMap.put(
766             PortletDataHandlerKeys.PORTLET_DATA,
767             new String[] {Boolean.TRUE.toString()});
768         parameterMap.put(
769             PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
770             new String[] {Boolean.TRUE.toString()});
771         parameterMap.put(
772             PortletDataHandlerKeys.PORTLET_SETUP,
773             new String[] {Boolean.TRUE.toString()});
774 
775         LayoutLocalServiceUtil.importLayouts(
776             defaultUserId, group.getGroupId(), false, parameterMap, larFile);
777     }
778 
779     protected String getFriendlyURL(String friendlyURL) {
780         friendlyURL = GetterUtil.getString(friendlyURL);
781 
782         return Normalizer.normalizeToAscii(friendlyURL.trim().toLowerCase());
783     }
784 
785     protected String getFriendlyURL(
786         long groupId, long classPK, String friendlyURL) {
787 
788         friendlyURL = getFriendlyURL(friendlyURL);
789 
790         if (Validator.isNull(friendlyURL)) {
791             if (classPK > 0) {
792                 friendlyURL = StringPool.SLASH + classPK;
793             }
794             else {
795                 friendlyURL = StringPool.SLASH + groupId;
796             }
797         }
798 
799         return friendlyURL;
800     }
801 
802     protected void initImportLARFile() {
803         String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
804 
805         if (_log.isDebugEnabled()) {
806             _log.debug("Reading public LAR file " + publicLARFileName);
807         }
808 
809         if (Validator.isNotNull(publicLARFileName)) {
810             publicLARFile = new File(publicLARFileName);
811 
812             if (!publicLARFile.exists()) {
813                 _log.error(
814                     "Public LAR file " + publicLARFile + " does not exist");
815 
816                 publicLARFile = null;
817             }
818             else {
819                 if (_log.isDebugEnabled()) {
820                     _log.debug("Using public LAR file " + publicLARFileName);
821                 }
822             }
823         }
824     }
825 
826     protected void unscheduleStaging(Group group) {
827         try {
828 
829             // Remote publishing
830 
831             String groupName = StagingUtil.getSchedulerGroupName(
832                 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
833 
834             List<SchedulerRequest> schedulerRequests =
835                 SchedulerEngineUtil.getScheduledJobs(groupName);
836 
837             for (SchedulerRequest schedulerRequest : schedulerRequests) {
838                 SchedulerEngineUtil.unschedule(
839                     schedulerRequest.getJobName(), groupName);
840             }
841 
842             long liveGroupId = 0;
843             long stagingGroupId = 0;
844 
845             if (group.isStagingGroup()) {
846                 liveGroupId = group.getLiveGroupId();
847 
848                 stagingGroupId = group.getGroupId();
849             }
850             else if (group.hasStagingGroup()) {
851                 liveGroupId = group.getGroupId();
852 
853                 stagingGroupId = group.getStagingGroup().getGroupId();
854             }
855 
856             if ((liveGroupId != 0) && (stagingGroupId != 0)) {
857 
858                 // Publish to live
859 
860                 groupName = StagingUtil.getSchedulerGroupName(
861                     DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
862 
863                 schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
864                     groupName);
865 
866                 for (SchedulerRequest schedulerRequest : schedulerRequests) {
867                     SchedulerEngineUtil.unschedule(
868                         schedulerRequest.getJobName(), groupName);
869                 }
870 
871                 // Copy from live
872 
873                 groupName = StagingUtil.getSchedulerGroupName(
874                     DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
875 
876                 schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
877                     groupName);
878 
879                 for (SchedulerRequest schedulerRequest : schedulerRequests) {
880                     SchedulerEngineUtil.unschedule(
881                         schedulerRequest.getJobName(), groupName);
882                 }
883             }
884         }
885         catch (Exception e) {
886             _log.error(
887                 "Unable to unschedule events for group: " + group.getGroupId());
888         }
889     }
890 
891     protected void validateFriendlyURL(
892             long groupId, long companyId, long classNameId, long classPK,
893             String friendlyURL)
894         throws PortalException, SystemException {
895 
896         if (Validator.isNull(friendlyURL)) {
897             return;
898         }
899 
900         int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
901 
902         if (exceptionType != -1) {
903             throw new GroupFriendlyURLException(exceptionType);
904         }
905 
906         try {
907             Group group = groupPersistence.findByC_F(companyId, friendlyURL);
908 
909             if (group.getGroupId() != groupId) {
910                 throw new GroupFriendlyURLException(
911                     GroupFriendlyURLException.DUPLICATE);
912             }
913         }
914         catch (NoSuchGroupException nsge) {
915         }
916 
917         String groupIdFriendlyURL = friendlyURL.substring(1);
918 
919         if (Validator.isNumber(groupIdFriendlyURL)) {
920             if (((classPK > 0) &&
921                  (!groupIdFriendlyURL.equals(String.valueOf(classPK)))) ||
922                 ((classPK == 0) &&
923                  (!groupIdFriendlyURL.equals(String.valueOf(groupId))))) {
924 
925                 GroupFriendlyURLException gfurle =
926                     new GroupFriendlyURLException(
927                         GroupFriendlyURLException.POSSIBLE_DUPLICATE);
928 
929                 gfurle.setKeywordConflict(groupIdFriendlyURL);
930 
931                 throw gfurle;
932             }
933         }
934 
935         String screenName = friendlyURL.substring(1);
936 
937         User user = userPersistence.fetchByC_SN(companyId, screenName);
938 
939         if (user != null) {
940             long userClassNameId = PortalUtil.getClassNameId(
941                 User.class.getName());
942 
943             if ((classNameId == userClassNameId) &&
944                 (classPK == user.getUserId())) {
945             }
946             else {
947                 throw new GroupFriendlyURLException(
948                     GroupFriendlyURLException.DUPLICATE);
949             }
950         }
951     }
952 
953     protected void validateName(long groupId, long companyId, String name)
954         throws PortalException, SystemException {
955 
956         if ((Validator.isNull(name)) || (Validator.isNumber(name)) ||
957             (name.indexOf(StringPool.COMMA) != -1) ||
958             (name.indexOf(StringPool.STAR) != -1)) {
959 
960             throw new GroupNameException();
961         }
962 
963         try {
964             Group group = groupFinder.findByC_N(companyId, name);
965 
966             if ((groupId <= 0) || (group.getGroupId() != groupId)) {
967                 throw new DuplicateGroupException();
968             }
969         }
970         catch (NoSuchGroupException nsge) {
971         }
972     }
973 
974     protected File publicLARFile;
975 
976     private static Log _log = LogFactory.getLog(GroupLocalServiceImpl.class);
977 
978 }