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