1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   * 
13   */
14  
15  package com.liferay.portal.service.impl;
16  
17  import com.liferay.portal.DuplicateGroupException;
18  import com.liferay.portal.GroupFriendlyURLException;
19  import com.liferay.portal.GroupNameException;
20  import com.liferay.portal.NoSuchGroupException;
21  import com.liferay.portal.NoSuchLayoutSetException;
22  import com.liferay.portal.NoSuchRoleException;
23  import com.liferay.portal.PortalException;
24  import com.liferay.portal.RequiredGroupException;
25  import com.liferay.portal.SystemException;
26  import com.liferay.portal.kernel.annotation.Propagation;
27  import com.liferay.portal.kernel.annotation.Transactional;
28  import com.liferay.portal.kernel.dao.orm.QueryUtil;
29  import com.liferay.portal.kernel.log.Log;
30  import com.liferay.portal.kernel.log.LogFactoryUtil;
31  import com.liferay.portal.kernel.messaging.DestinationNames;
32  import com.liferay.portal.kernel.scheduler.SchedulerEngineUtil;
33  import com.liferay.portal.kernel.scheduler.messaging.SchedulerRequest;
34  import com.liferay.portal.kernel.util.GetterUtil;
35  import com.liferay.portal.kernel.util.OrderByComparator;
36  import com.liferay.portal.kernel.util.PropsKeys;
37  import com.liferay.portal.kernel.util.StringPool;
38  import com.liferay.portal.kernel.util.StringUtil;
39  import com.liferay.portal.kernel.util.UnicodeProperties;
40  import com.liferay.portal.kernel.util.Validator;
41  import com.liferay.portal.lar.PortletDataHandlerKeys;
42  import com.liferay.portal.model.Company;
43  import com.liferay.portal.model.Group;
44  import com.liferay.portal.model.GroupConstants;
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.RoleConstants;
54  import com.liferay.portal.model.User;
55  import com.liferay.portal.model.UserGroup;
56  import com.liferay.portal.model.impl.LayoutImpl;
57  import com.liferay.portal.security.permission.PermissionCacheUtil;
58  import com.liferay.portal.service.base.GroupLocalServiceBaseImpl;
59  import com.liferay.portal.util.FriendlyURLNormalizer;
60  import com.liferay.portal.util.PortalUtil;
61  import com.liferay.portal.util.PropsUtil;
62  import com.liferay.portal.util.PropsValues;
63  import com.liferay.portal.util.comparator.GroupNameComparator;
64  import com.liferay.portlet.communities.util.StagingUtil;
65  
66  import java.io.File;
67  
68  import java.util.ArrayList;
69  import java.util.HashMap;
70  import java.util.Iterator;
71  import java.util.LinkedHashMap;
72  import java.util.List;
73  import java.util.Map;
74  
75  /**
76   * <a href="GroupLocalServiceImpl.java.html"><b><i>View Source</i></b></a>
77   *
78   * @author Brian Wing Shun Chan
79   * @author Alexander Chow
80   * @author Bruno Farache
81   * @author Wesley Gong
82   */
83  public class GroupLocalServiceImpl extends GroupLocalServiceBaseImpl {
84  
85      public GroupLocalServiceImpl() {
86          initImportLARFile();
87      }
88  
89      public Group addGroup(
90              long userId, String className, long classPK, String name,
91              String description, int type, String friendlyURL, boolean active)
92          throws PortalException, SystemException {
93  
94          return addGroup(
95              userId, className, classPK, GroupConstants.DEFAULT_LIVE_GROUP_ID,
96              name, description, type, friendlyURL, active);
97      }
98  
99      public Group addGroup(
100             long userId, String className, long classPK, long liveGroupId,
101             String name, String description, int type, String friendlyURL,
102             boolean active)
103         throws PortalException, SystemException {
104 
105         // Group
106 
107         User user = userPersistence.findByPrimaryKey(userId);
108         className = GetterUtil.getString(className);
109         long classNameId = PortalUtil.getClassNameId(className);
110 
111         long groupId = 0;
112 
113         while (true) {
114             groupId = counterLocalService.increment();
115 
116             User userScreenName = userPersistence.fetchByC_SN(
117                 user.getCompanyId(), String.valueOf(groupId));
118 
119             if (userScreenName == null) {
120                 break;
121             }
122         }
123 
124         friendlyURL = getFriendlyURL(groupId, classPK, friendlyURL);
125 
126         long groupClassNameId = PortalUtil.getClassNameId(Group.class);
127 
128         if ((classNameId <= 0) || className.equals(Group.class.getName())) {
129             validateName(groupId, user.getCompanyId(), name);
130 
131             classNameId = groupClassNameId;
132             classPK = groupId;
133         }
134         else {
135             name = String.valueOf(classPK);
136         }
137 
138         validateFriendlyURL(
139             user.getCompanyId(), groupId, classNameId, classPK, friendlyURL);
140 
141         Group group = groupPersistence.create(groupId);
142 
143         group.setCompanyId(user.getCompanyId());
144         group.setCreatorUserId(userId);
145         group.setClassNameId(classNameId);
146         group.setClassPK(classPK);
147         group.setParentGroupId(GroupConstants.DEFAULT_PARENT_GROUP_ID);
148         group.setLiveGroupId(liveGroupId);
149         group.setName(name);
150         group.setDescription(description);
151         group.setType(type);
152         group.setFriendlyURL(friendlyURL);
153         group.setActive(active);
154 
155         groupPersistence.update(group, false);
156 
157         // Layout sets
158 
159         layoutSetLocalService.addLayoutSet(groupId, true);
160 
161         layoutSetLocalService.addLayoutSet(groupId, false);
162 
163         if ((classNameId == groupClassNameId) && !user.isDefaultUser()) {
164 
165             // Resources
166 
167             resourceLocalService.addResources(
168                 group.getCompanyId(), 0, 0, Group.class.getName(),
169                 group.getGroupId(), false, false, false);
170 
171             // Community roles
172 
173             Role role = roleLocalService.getRole(
174                 group.getCompanyId(), RoleConstants.COMMUNITY_OWNER);
175 
176             userGroupRoleLocalService.addUserGroupRoles(
177                 userId, groupId, new long[] {role.getRoleId()});
178 
179             // User
180 
181             userLocalService.addGroupUsers(
182                 group.getGroupId(), new long[] {userId});
183         }
184         else if (className.equals(Organization.class.getName()) &&
185                  !user.isDefaultUser()) {
186 
187             // Resources
188 
189             resourceLocalService.addResources(
190                 group.getCompanyId(), 0, 0, Group.class.getName(),
191                 group.getGroupId(), false, false, false);
192         }
193 
194         return group;
195     }
196 
197     public void addRoleGroups(long roleId, long[] groupIds)
198         throws SystemException {
199 
200         rolePersistence.addGroups(roleId, groupIds);
201 
202         PermissionCacheUtil.clearCache();
203     }
204 
205     public void addUserGroups(long userId, long[] groupIds)
206         throws SystemException {
207 
208         userPersistence.addGroups(userId, groupIds);
209 
210         PermissionCacheUtil.clearCache();
211     }
212 
213     @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
214     public void checkSystemGroups(long companyId)
215         throws PortalException, SystemException {
216 
217         for (Group group : groupFinder.findBySystem(companyId)) {
218             _systemGroupsMap.put(companyId + group.getName(), group);
219         }
220 
221         long defaultUserId = userLocalService.getDefaultUserId(companyId);
222 
223         String[] systemGroups = PortalUtil.getSystemGroups();
224 
225         for (String name : systemGroups) {
226             Group group = _systemGroupsMap.get(companyId + name);
227 
228             try {
229                 if (group == null) {
230                     group = groupPersistence.findByC_N(companyId, name);
231                 }
232             }
233             catch (NoSuchGroupException nsge) {
234                 String friendlyURL = null;
235 
236                 if (name.equals(GroupConstants.GUEST)) {
237                     friendlyURL = "/guest";
238                 }
239 
240                 group = groupLocalService.addGroup(
241                     defaultUserId, null, 0, name, null,
242                     GroupConstants.TYPE_COMMUNITY_OPEN, friendlyURL, true);
243             }
244 
245             if (group.getName().equals(GroupConstants.GUEST)) {
246                 LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
247                     group.getGroupId(), false);
248 
249                 if (layoutSet.getPageCount() == 0) {
250                     addDefaultGuestPublicLayouts(group);
251                 }
252             }
253 
254             _systemGroupsMap.put(companyId + name, group);
255         }
256     }
257 
258     public void deleteGroup(long groupId)
259         throws PortalException, SystemException {
260 
261         Group group = groupPersistence.findByPrimaryKey(groupId);
262 
263         if (PortalUtil.isSystemGroup(group.getName())) {
264             throw new RequiredGroupException(String.valueOf(groupId));
265         }
266 
267         // Layout sets
268 
269         try {
270             layoutSetLocalService.deleteLayoutSet(groupId, true);
271         }
272         catch (NoSuchLayoutSetException nslse) {
273         }
274 
275         try {
276             layoutSetLocalService.deleteLayoutSet(groupId, false);
277         }
278         catch (NoSuchLayoutSetException nslse) {
279         }
280 
281         // Role
282 
283         try {
284             Role role = roleLocalService.getGroupRole(
285                 group.getCompanyId(), groupId);
286 
287             roleLocalService.deleteRole(role.getRoleId());
288         }
289         catch (NoSuchRoleException nsre) {
290         }
291 
292         // Group roles
293 
294         userGroupRoleLocalService.deleteUserGroupRolesByGroupId(groupId);
295 
296         // Membership requests
297 
298         membershipRequestLocalService.deleteMembershipRequests(
299             group.getGroupId());
300 
301         // Staging
302 
303         unscheduleStaging(group);
304 
305         if (group.hasStagingGroup()) {
306             deleteGroup(group.getStagingGroup().getGroupId());
307         }
308 
309         // Blogs
310 
311         blogsEntryLocalService.deleteEntries(groupId);
312         blogsStatsUserLocalService.deleteStatsUserByGroupId(groupId);
313 
314         // Bookmarks
315 
316         bookmarksFolderLocalService.deleteFolders(groupId);
317 
318         // Calendar
319 
320         calEventLocalService.deleteEvents(groupId);
321 
322         // Document library
323 
324         dlFolderLocalService.deleteFolders(groupId);
325 
326         // Image gallery
327 
328         igFolderLocalService.deleteFolders(groupId);
329 
330         // Journal
331 
332         journalArticleLocalService.deleteArticles(groupId);
333         journalTemplateLocalService.deleteTemplates(groupId);
334         journalStructureLocalService.deleteStructures(groupId);
335 
336         // Message boards
337 
338         mbBanLocalService.deleteBansByGroupId(groupId);
339         mbCategoryLocalService.deleteCategories(groupId);
340         mbStatsUserLocalService.deleteStatsUsersByGroupId(groupId);
341 
342         // Polls
343 
344         pollsQuestionLocalService.deleteQuestions(groupId);
345 
346         // Shopping
347 
348         shoppingCartLocalService.deleteGroupCarts(groupId);
349         shoppingCategoryLocalService.deleteCategories(groupId);
350         shoppingCouponLocalService.deleteCoupons(groupId);
351         shoppingOrderLocalService.deleteOrders(groupId);
352 
353         // Software catalog
354 
355         scFrameworkVersionLocalService.deleteFrameworkVersions(groupId);
356         scProductEntryLocalService.deleteProductEntries(groupId);
357 
358         // Wiki
359 
360         wikiNodeLocalService.deleteNodes(groupId);
361 
362         // Resources
363 
364         Iterator<Resource> itr = resourceFinder.findByC_P(
365             group.getCompanyId(), String.valueOf(groupId)).iterator();
366 
367         while (itr.hasNext()) {
368             Resource resource = itr.next();
369 
370             resourceLocalService.deleteResource(resource);
371         }
372 
373         if (!group.isStagingGroup() &&
374             (group.isCommunity() || group.isOrganization())) {
375 
376             resourceLocalService.deleteResource(
377                 group.getCompanyId(), Group.class.getName(),
378                 ResourceConstants.SCOPE_INDIVIDUAL, group.getGroupId());
379         }
380 
381         // Group
382 
383         groupPersistence.remove(group);
384 
385         // Permission cache
386 
387         PermissionCacheUtil.clearCache();
388     }
389 
390     public List<Group> getCompanyGroups(long companyId, int start, int end)
391         throws SystemException {
392 
393         return groupPersistence.findByCompanyId(companyId, start, end);
394     }
395 
396     public int getCompanyGroupsCount(long companyId) throws SystemException {
397         return groupPersistence.countByCompanyId(companyId);
398     }
399 
400     public Group getFriendlyURLGroup(long companyId, String friendlyURL)
401         throws PortalException, SystemException {
402 
403         if (Validator.isNull(friendlyURL)) {
404             throw new NoSuchGroupException();
405         }
406 
407         friendlyURL = getFriendlyURL(friendlyURL);
408 
409         return groupPersistence.findByC_F(companyId, friendlyURL);
410     }
411 
412     public Group getGroup(long groupId)
413         throws PortalException, SystemException {
414 
415         return groupPersistence.findByPrimaryKey(groupId);
416     }
417 
418     public Group getGroup(long companyId, String name)
419         throws PortalException, SystemException {
420 
421         Group group = _systemGroupsMap.get(companyId + name);
422 
423         if (group != null) {
424             return group;
425         }
426 
427         return groupPersistence.findByC_N(companyId, name);
428     }
429 
430     public List<Group> getNoLayoutsGroups(
431             String className, boolean privateLayout, int start, int end)
432         throws SystemException {
433 
434         long classNameId = PortalUtil.getClassNameId(className);
435 
436         return groupFinder.findByNoLayouts(
437             classNameId, privateLayout, start, end);
438     }
439 
440     public List<Group> getNullFriendlyURLGroups() throws SystemException {
441         return groupFinder.findByNullFriendlyURL();
442     }
443 
444     public Group getOrganizationGroup(long companyId, long organizationId)
445         throws PortalException, SystemException {
446 
447         long classNameId = PortalUtil.getClassNameId(Organization.class);
448 
449         return groupPersistence.findByC_C_C(
450             companyId, classNameId, organizationId);
451     }
452 
453     public List<Group> getOrganizationsGroups(
454         List<Organization> organizations) {
455 
456         List<Group> organizationGroups = new ArrayList<Group>();
457 
458         for (int i = 0; i < organizations.size(); i++) {
459             Organization organization = organizations.get(i);
460 
461             Group group = organization.getGroup();
462 
463             organizationGroups.add(group);
464         }
465 
466         return organizationGroups;
467     }
468 
469     public List<Group> getRoleGroups(long roleId) throws SystemException {
470         return rolePersistence.getGroups(roleId);
471     }
472 
473     public Group getStagingGroup(long liveGroupId)
474         throws PortalException, SystemException {
475 
476         return groupPersistence.findByLiveGroupId(liveGroupId);
477     }
478 
479     public Group getUserGroup(long companyId, long userId)
480         throws PortalException, SystemException {
481 
482         long classNameId = PortalUtil.getClassNameId(User.class);
483 
484         return groupPersistence.findByC_C_C(companyId, classNameId, userId);
485     }
486 
487     public Group getUserGroupGroup(long companyId, long userGroupId)
488         throws PortalException, SystemException {
489 
490         long classNameId = PortalUtil.getClassNameId(UserGroup.class);
491 
492         return groupPersistence.findByC_C_C(
493             companyId, classNameId, userGroupId);
494     }
495 
496     public List<Group> getUserGroups(long userId)
497         throws PortalException, SystemException {
498 
499         return getUserGroups(userId, false);
500     }
501 
502     public List<Group> getUserGroups(long userId, boolean inherit)
503         throws PortalException, SystemException {
504 
505         return getUserGroups(
506             userId, inherit, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
507     }
508 
509     public List<Group> getUserGroups(long userId, int start, int end)
510         throws PortalException, SystemException {
511 
512         return getUserGroups(userId, false, start, end);
513     }
514 
515     public List<Group> getUserGroups(
516             long userId, boolean inherit, int start, int end)
517         throws PortalException, SystemException {
518 
519         if (inherit) {
520             User user = userPersistence.findByPrimaryKey(userId);
521 
522             LinkedHashMap<String, Object> groupParams =
523                 new LinkedHashMap<String, Object>();
524 
525             groupParams.put("usersGroups", new Long(userId));
526 
527             return search(
528                 user.getCompanyId(), null, null, groupParams, start, end);
529         }
530         else {
531             return userPersistence.getGroups(userId);
532         }
533     }
534 
535     public List<Group> getUserGroupsGroups(List<UserGroup> userGroups) {
536         List<Group> userGroupGroups = new ArrayList<Group>();
537 
538         for (int i = 0; i < userGroups.size(); i++) {
539             UserGroup userGroup = userGroups.get(i);
540 
541             Group group = userGroup.getGroup();
542 
543             userGroupGroups.add(group);
544         }
545 
546         return userGroupGroups;
547     }
548 
549     public boolean hasRoleGroup(long roleId, long groupId)
550         throws SystemException {
551 
552         return rolePersistence.containsGroup(roleId, groupId);
553     }
554 
555     public boolean hasStagingGroup(long liveGroupId) throws SystemException {
556         if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
557             return true;
558         }
559         else {
560             return false;
561         }
562     }
563 
564     public boolean hasUserGroup(long userId, long groupId)
565         throws SystemException {
566 
567         if (groupFinder.countByG_U(groupId, userId) > 0) {
568             return true;
569         }
570         else {
571             return false;
572         }
573     }
574 
575     public List<Group> search(
576             long companyId, String name, String description,
577             LinkedHashMap<String, Object> params, int start, int end)
578         throws SystemException {
579 
580         return search(companyId, name, description, params, start, end, null);
581     }
582 
583     public List<Group> search(
584             long companyId, String name, String description,
585             LinkedHashMap<String, Object> params, int start, int end,
586             OrderByComparator obc)
587         throws SystemException {
588 
589         if (obc == null) {
590             obc = new GroupNameComparator(true);
591         }
592 
593         return groupFinder.findByC_N_D(
594             companyId, name, description, params, start, end, obc);
595     }
596 
597     public int searchCount(
598             long companyId, String name, String description,
599             LinkedHashMap<String, Object> params)
600         throws SystemException {
601 
602         return groupFinder.countByC_N_D(companyId, name, description, params);
603     }
604 
605     public void setRoleGroups(long roleId, long[] groupIds)
606         throws SystemException {
607 
608         rolePersistence.setGroups(roleId, groupIds);
609 
610         PermissionCacheUtil.clearCache();
611     }
612 
613     public void unsetRoleGroups(long roleId, long[] groupIds)
614         throws SystemException {
615 
616         rolePersistence.removeGroups(roleId, groupIds);
617 
618         PermissionCacheUtil.clearCache();
619     }
620 
621     public void unsetUserGroups(long userId, long[] groupIds)
622         throws SystemException {
623 
624         userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
625 
626         userPersistence.removeGroups(userId, groupIds);
627 
628         PermissionCacheUtil.clearCache();
629     }
630 
631     public Group updateFriendlyURL(long groupId, String friendlyURL)
632         throws PortalException, SystemException {
633 
634         Group group = groupPersistence.findByPrimaryKey(groupId);
635 
636         if (group.isUser()) {
637             User user = userPersistence.findByPrimaryKey(group.getClassPK());
638 
639             friendlyURL = StringPool.SLASH + user.getScreenName();
640 
641             if (group.getFriendlyURL().equals(friendlyURL)) {
642                 return group;
643             }
644         }
645 
646         friendlyURL = getFriendlyURL(groupId, group.getClassPK(), friendlyURL);
647 
648         validateFriendlyURL(
649             group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
650             group.getClassPK(), friendlyURL);
651 
652         group.setFriendlyURL(friendlyURL);
653 
654         groupPersistence.update(group, false);
655 
656         return group;
657     }
658 
659     public Group updateGroup(
660             long groupId, String name, String description, int type,
661             String friendlyURL, boolean active)
662         throws PortalException, SystemException {
663 
664         Group group = groupPersistence.findByPrimaryKey(groupId);
665 
666         String className = group.getClassName();
667         long classNameId = group.getClassNameId();
668         long classPK = group.getClassPK();
669         friendlyURL = getFriendlyURL(groupId, classPK, friendlyURL);
670 
671         if ((classNameId <= 0) || className.equals(Group.class.getName())) {
672             validateName(group.getGroupId(), group.getCompanyId(), name);
673         }
674         else {
675             name = String.valueOf(classPK);
676         }
677 
678         if (PortalUtil.isSystemGroup(group.getName()) &&
679             !group.getName().equals(name)) {
680 
681             throw new RequiredGroupException();
682         }
683 
684         validateFriendlyURL(
685             group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
686             group.getClassPK(), friendlyURL);
687 
688         group.setName(name);
689         group.setDescription(description);
690         group.setType(type);
691         group.setFriendlyURL(friendlyURL);
692         group.setActive(active);
693 
694         groupPersistence.update(group, false);
695 
696         return group;
697     }
698 
699     public Group updateGroup(long groupId, String typeSettings)
700         throws PortalException, SystemException {
701 
702         Group group = groupPersistence.findByPrimaryKey(groupId);
703 
704         group.setTypeSettings(typeSettings);
705 
706         groupPersistence.update(group, false);
707 
708         return group;
709     }
710 
711     public Group updateWorkflow(
712             long groupId, boolean workflowEnabled, int workflowStages,
713             String workflowRoleNames)
714         throws PortalException, SystemException {
715 
716         Group group = groupPersistence.findByPrimaryKey(groupId);
717 
718         UnicodeProperties props = group.getTypeSettingsProperties();
719 
720         props.setProperty("workflowEnabled", String.valueOf(workflowEnabled));
721 
722         if (workflowEnabled) {
723             if (workflowStages < PropsValues.TASKS_DEFAULT_STAGES) {
724                 workflowStages = PropsValues.TASKS_DEFAULT_STAGES;
725             }
726 
727             if (Validator.isNull(workflowRoleNames)) {
728                 workflowRoleNames = PropsValues.TASKS_DEFAULT_ROLE_NAMES;
729             }
730 
731             props.setProperty("workflowStages", String.valueOf(workflowStages));
732             props.setProperty("workflowRoleNames", workflowRoleNames);
733         }
734 
735         group.setTypeSettings(group.getTypeSettings());
736 
737         groupPersistence.update(group, false);
738 
739         if (!workflowEnabled) {
740             tasksProposalLocalService.deleteProposals(groupId);
741         }
742 
743         return group;
744     }
745 
746     protected void addDefaultGuestPublicLayoutByProperties(Group group)
747         throws PortalException, SystemException {
748 
749         long defaultUserId = userLocalService.getDefaultUserId(
750             group.getCompanyId());
751         String friendlyURL = getFriendlyURL(
752             PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
753 
754         Layout layout = layoutLocalService.addLayout(
755             defaultUserId, group.getGroupId(), false,
756             LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
757             PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
758             StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL);
759 
760         LayoutTypePortlet layoutTypePortlet =
761             (LayoutTypePortlet)layout.getLayoutType();
762 
763         layoutTypePortlet.setLayoutTemplateId(
764             0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
765 
766         for (int i = 0; i < 10; i++) {
767             String columnId = "column-" + i;
768             String portletIds = PropsUtil.get(
769                 PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_COLUMN + i);
770 
771             layoutTypePortlet.addPortletIds(
772                 0, StringUtil.split(portletIds), columnId, false);
773         }
774 
775         layoutLocalService.updateLayout(
776             layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
777             layout.getTypeSettings());
778 
779         boolean updateLayoutSet = false;
780 
781         LayoutSet layoutSet = layout.getLayoutSet();
782 
783         if (Validator.isNotNull(
784                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
785 
786             layoutSet.setThemeId(
787                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
788 
789             updateLayoutSet = true;
790         }
791 
792         if (Validator.isNotNull(
793                 PropsValues.
794                     DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
795 
796             layoutSet.setColorSchemeId(
797                 PropsValues.
798                     DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
799 
800             updateLayoutSet = true;
801         }
802 
803         if (Validator.isNotNull(
804                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
805 
806             layoutSet.setWapThemeId(
807                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
808 
809             updateLayoutSet = true;
810         }
811 
812         if (Validator.isNotNull(
813                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
814 
815             layoutSet.setWapColorSchemeId(
816                 PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
817 
818             updateLayoutSet = true;
819         }
820 
821         if (updateLayoutSet) {
822             layoutSetLocalService.updateLayoutSet(layoutSet);
823         }
824     }
825 
826     protected void addDefaultGuestPublicLayouts(Group group)
827         throws PortalException, SystemException {
828 
829         if (publicLARFile != null) {
830             addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
831         }
832         else {
833             addDefaultGuestPublicLayoutByProperties(group);
834         }
835     }
836 
837     protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
838         throws PortalException, SystemException {
839 
840         long defaultUserId = userLocalService.getDefaultUserId(
841             group.getCompanyId());
842 
843         Map<String, String[]> parameterMap = new HashMap<String, String[]>();
844 
845         parameterMap.put(
846             PortletDataHandlerKeys.PERMISSIONS,
847             new String[] {Boolean.TRUE.toString()});
848         parameterMap.put(
849             PortletDataHandlerKeys.PORTLET_DATA,
850             new String[] {Boolean.TRUE.toString()});
851         parameterMap.put(
852             PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
853             new String[] {Boolean.TRUE.toString()});
854         parameterMap.put(
855             PortletDataHandlerKeys.PORTLET_SETUP,
856             new String[] {Boolean.TRUE.toString()});
857         parameterMap.put(
858             PortletDataHandlerKeys.USER_PERMISSIONS,
859             new String[] {Boolean.FALSE.toString()});
860 
861         layoutLocalService.importLayouts(
862             defaultUserId, group.getGroupId(), false, parameterMap, larFile);
863     }
864 
865     protected String getFriendlyURL(String friendlyURL) {
866         return FriendlyURLNormalizer.normalize(friendlyURL);
867     }
868 
869     protected String getFriendlyURL(
870         long groupId, long classPK, String friendlyURL) {
871 
872         friendlyURL = getFriendlyURL(friendlyURL);
873 
874         if (Validator.isNull(friendlyURL)) {
875             if (classPK > 0) {
876                 friendlyURL = StringPool.SLASH + classPK;
877             }
878             else {
879                 friendlyURL = StringPool.SLASH + groupId;
880             }
881         }
882 
883         return friendlyURL;
884     }
885 
886     protected void initImportLARFile() {
887         String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
888 
889         if (_log.isDebugEnabled()) {
890             _log.debug("Reading public LAR file " + publicLARFileName);
891         }
892 
893         if (Validator.isNotNull(publicLARFileName)) {
894             publicLARFile = new File(publicLARFileName);
895 
896             if (!publicLARFile.exists()) {
897                 _log.error(
898                     "Public LAR file " + publicLARFile + " does not exist");
899 
900                 publicLARFile = null;
901             }
902             else {
903                 if (_log.isDebugEnabled()) {
904                     _log.debug("Using public LAR file " + publicLARFileName);
905                 }
906             }
907         }
908     }
909 
910     protected void unscheduleStaging(Group group) {
911         try {
912 
913             // Remote publishing
914 
915             String groupName = StagingUtil.getSchedulerGroupName(
916                 DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
917 
918             List<SchedulerRequest> schedulerRequests =
919                 SchedulerEngineUtil.getScheduledJobs(groupName);
920 
921             for (SchedulerRequest schedulerRequest : schedulerRequests) {
922                 SchedulerEngineUtil.unschedule(
923                     schedulerRequest.getJobName(), groupName);
924             }
925 
926             long liveGroupId = 0;
927             long stagingGroupId = 0;
928 
929             if (group.isStagingGroup()) {
930                 liveGroupId = group.getLiveGroupId();
931 
932                 stagingGroupId = group.getGroupId();
933             }
934             else if (group.hasStagingGroup()) {
935                 liveGroupId = group.getGroupId();
936 
937                 stagingGroupId = group.getStagingGroup().getGroupId();
938             }
939 
940             if ((liveGroupId != 0) && (stagingGroupId != 0)) {
941 
942                 // Publish to live
943 
944                 groupName = StagingUtil.getSchedulerGroupName(
945                     DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
946 
947                 schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
948                     groupName);
949 
950                 for (SchedulerRequest schedulerRequest : schedulerRequests) {
951                     SchedulerEngineUtil.unschedule(
952                         schedulerRequest.getJobName(), groupName);
953                 }
954 
955                 // Copy from live
956 
957                 groupName = StagingUtil.getSchedulerGroupName(
958                     DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
959 
960                 schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
961                     groupName);
962 
963                 for (SchedulerRequest schedulerRequest : schedulerRequests) {
964                     SchedulerEngineUtil.unschedule(
965                         schedulerRequest.getJobName(), groupName);
966                 }
967             }
968         }
969         catch (Exception e) {
970             _log.error(
971                 "Unable to unschedule events for group: " + group.getGroupId());
972         }
973     }
974 
975     protected void validateFriendlyURL(
976             long companyId, long groupId, long classNameId, long classPK,
977             String friendlyURL)
978         throws PortalException, SystemException {
979 
980         Company company = companyPersistence.findByPrimaryKey(companyId);
981 
982         if (company.isSystem()) {
983             return;
984         }
985 
986         if (Validator.isNull(friendlyURL)) {
987             return;
988         }
989 
990         int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
991 
992         if (exceptionType != -1) {
993             throw new GroupFriendlyURLException(exceptionType);
994         }
995 
996         Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
997 
998         if ((group != null) && (group.getGroupId() != groupId)) {
999             throw new GroupFriendlyURLException(
1000                GroupFriendlyURLException.DUPLICATE);
1001        }
1002
1003        String groupIdFriendlyURL = friendlyURL.substring(1);
1004
1005        if (Validator.isNumber(groupIdFriendlyURL)) {
1006            long groupClassNameId = PortalUtil.getClassNameId(Group.class);
1007
1008            if (((classNameId != groupClassNameId) &&
1009                 (!groupIdFriendlyURL.equals(String.valueOf(classPK))) &&
1010                 (!PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC)) ||
1011                ((classNameId == groupClassNameId) &&
1012                 (!groupIdFriendlyURL.equals(String.valueOf(groupId))))) {
1013
1014                GroupFriendlyURLException gfurle =
1015                    new GroupFriendlyURLException(
1016                        GroupFriendlyURLException.POSSIBLE_DUPLICATE);
1017
1018                gfurle.setKeywordConflict(groupIdFriendlyURL);
1019
1020                throw gfurle;
1021            }
1022        }
1023
1024        String screenName = friendlyURL.substring(1);
1025
1026        User user = userPersistence.fetchByC_SN(companyId, screenName);
1027
1028        if (user != null) {
1029            long userClassNameId = PortalUtil.getClassNameId(User.class);
1030
1031            if ((classNameId == userClassNameId) &&
1032                (classPK == user.getUserId())) {
1033            }
1034            else {
1035                throw new GroupFriendlyURLException(
1036                    GroupFriendlyURLException.DUPLICATE);
1037            }
1038        }
1039
1040        if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
1041            throw new GroupFriendlyURLException(
1042                GroupFriendlyURLException.TOO_DEEP);
1043        }
1044    }
1045
1046    protected void validateName(long groupId, long companyId, String name)
1047        throws PortalException, SystemException {
1048
1049        if ((Validator.isNull(name)) || (Validator.isNumber(name)) ||
1050            (name.indexOf(StringPool.COMMA) != -1) ||
1051            (name.indexOf(StringPool.STAR) != -1)) {
1052
1053            throw new GroupNameException();
1054        }
1055
1056        try {
1057            Group group = groupFinder.findByC_N(companyId, name);
1058
1059            if ((groupId <= 0) || (group.getGroupId() != groupId)) {
1060                throw new DuplicateGroupException();
1061            }
1062        }
1063        catch (NoSuchGroupException nsge) {
1064        }
1065    }
1066
1067    protected File publicLARFile;
1068
1069    private static Log _log = LogFactoryUtil.getLog(
1070        GroupLocalServiceImpl.class);
1071
1072    private Map<String, Group> _systemGroupsMap = new HashMap<String, Group>();
1073
1074}