001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.impl;
016    
017    import com.liferay.portal.DuplicateGroupException;
018    import com.liferay.portal.GroupFriendlyURLException;
019    import com.liferay.portal.GroupNameException;
020    import com.liferay.portal.NoSuchGroupException;
021    import com.liferay.portal.NoSuchLayoutSetException;
022    import com.liferay.portal.NoSuchUserException;
023    import com.liferay.portal.RequiredGroupException;
024    import com.liferay.portal.kernel.annotation.Propagation;
025    import com.liferay.portal.kernel.annotation.Transactional;
026    import com.liferay.portal.kernel.cache.ThreadLocalCachable;
027    import com.liferay.portal.kernel.dao.orm.QueryUtil;
028    import com.liferay.portal.kernel.exception.PortalException;
029    import com.liferay.portal.kernel.exception.SystemException;
030    import com.liferay.portal.kernel.lar.PortletDataHandlerKeys;
031    import com.liferay.portal.kernel.log.Log;
032    import com.liferay.portal.kernel.log.LogFactoryUtil;
033    import com.liferay.portal.kernel.messaging.DestinationNames;
034    import com.liferay.portal.kernel.scheduler.SchedulerEngineUtil;
035    import com.liferay.portal.kernel.scheduler.messaging.SchedulerRequest;
036    import com.liferay.portal.kernel.staging.StagingUtil;
037    import com.liferay.portal.kernel.util.CharPool;
038    import com.liferay.portal.kernel.util.GetterUtil;
039    import com.liferay.portal.kernel.util.OrderByComparator;
040    import com.liferay.portal.kernel.util.ParamUtil;
041    import com.liferay.portal.kernel.util.PropsKeys;
042    import com.liferay.portal.kernel.util.StringPool;
043    import com.liferay.portal.kernel.util.StringUtil;
044    import com.liferay.portal.kernel.util.UnicodeProperties;
045    import com.liferay.portal.kernel.util.Validator;
046    import com.liferay.portal.model.Account;
047    import com.liferay.portal.model.Company;
048    import com.liferay.portal.model.Group;
049    import com.liferay.portal.model.GroupConstants;
050    import com.liferay.portal.model.Layout;
051    import com.liferay.portal.model.LayoutConstants;
052    import com.liferay.portal.model.LayoutPrototype;
053    import com.liferay.portal.model.LayoutSet;
054    import com.liferay.portal.model.LayoutSetPrototype;
055    import com.liferay.portal.model.LayoutTypePortlet;
056    import com.liferay.portal.model.Organization;
057    import com.liferay.portal.model.Resource;
058    import com.liferay.portal.model.ResourceConstants;
059    import com.liferay.portal.model.Role;
060    import com.liferay.portal.model.RoleConstants;
061    import com.liferay.portal.model.User;
062    import com.liferay.portal.model.UserGroup;
063    import com.liferay.portal.model.impl.LayoutImpl;
064    import com.liferay.portal.security.permission.PermissionCacheUtil;
065    import com.liferay.portal.service.ServiceContext;
066    import com.liferay.portal.service.base.GroupLocalServiceBaseImpl;
067    import com.liferay.portal.util.FriendlyURLNormalizer;
068    import com.liferay.portal.util.PortalUtil;
069    import com.liferay.portal.util.PropsUtil;
070    import com.liferay.portal.util.PropsValues;
071    import com.liferay.portal.util.comparator.GroupNameComparator;
072    import com.liferay.portlet.blogs.model.BlogsEntry;
073    import com.liferay.portlet.journal.model.JournalArticle;
074    import com.liferay.util.UniqueList;
075    
076    import java.io.File;
077    
078    import java.util.ArrayList;
079    import java.util.HashMap;
080    import java.util.Iterator;
081    import java.util.LinkedHashMap;
082    import java.util.List;
083    import java.util.Map;
084    
085    /**
086     * @author Brian Wing Shun Chan
087     * @author Alexander Chow
088     * @author Bruno Farache
089     * @author Wesley Gong
090     */
091    public class GroupLocalServiceImpl extends GroupLocalServiceBaseImpl {
092    
093            public GroupLocalServiceImpl() {
094                    initImportLARFile();
095            }
096    
097            public Group addGroup(
098                            long userId, String className, long classPK, String name,
099                            String description, int type, String friendlyURL, boolean active,
100                            ServiceContext serviceContext)
101                    throws PortalException, SystemException {
102    
103                    return addGroup(
104                            userId, className, classPK, GroupConstants.DEFAULT_LIVE_GROUP_ID,
105                            name, description, type, friendlyURL, active, serviceContext);
106            }
107    
108            public Group addGroup(
109                            long userId, String className, long classPK, long liveGroupId,
110                            String name, String description, int type, String friendlyURL,
111                            boolean active, ServiceContext serviceContext)
112                    throws PortalException, SystemException {
113    
114                    // Group
115    
116                    User user = userPersistence.findByPrimaryKey(userId);
117                    className = GetterUtil.getString(className);
118                    long classNameId = PortalUtil.getClassNameId(className);
119    
120                    String friendlyName = name;
121    
122                    if (className.equals(Organization.class.getName())) {
123                            Organization organization =
124                                    organizationPersistence.findByPrimaryKey(classPK);
125    
126                            friendlyName = organization.getName();
127                            name = String.valueOf(classPK);
128                    }
129    
130                    long groupId = 0;
131    
132                    while (true) {
133                            groupId = counterLocalService.increment();
134    
135                            User userScreenName = userPersistence.fetchByC_SN(
136                                    user.getCompanyId(), String.valueOf(groupId));
137    
138                            if (userScreenName == null) {
139                                    break;
140                            }
141                    }
142    
143                    boolean staging = isStaging(serviceContext);
144    
145                    long groupClassNameId = PortalUtil.getClassNameId(Group.class);
146    
147                    if ((classNameId <= 0) || className.equals(Group.class.getName())) {
148                            classNameId = groupClassNameId;
149                            classPK = groupId;
150                    }
151                    else if (className.equals(Organization.class.getName()) && staging) {
152                            classPK = liveGroupId;
153                    }
154                    else {
155                            name = String.valueOf(classPK);
156                    }
157    
158                    long parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
159    
160                    if (className.equals(Layout.class.getName())) {
161                            Layout layout = layoutLocalService.getLayout(classPK);
162    
163                            parentGroupId = layout.getGroupId();
164                    }
165    
166                    friendlyURL = getFriendlyURL(
167                            user.getCompanyId(), groupId, classNameId, classPK, friendlyName,
168                            friendlyURL);
169    
170                    if (staging) {
171                            name = name.concat(" (Staging)");
172                            friendlyURL = friendlyURL.concat("-staging");
173                    }
174    
175                    if ((classNameId <= 0) || className.equals(Group.class.getName())) {
176                            validateName(groupId, user.getCompanyId(), name);
177                    }
178    
179                    validateFriendlyURL(
180                            user.getCompanyId(), groupId, classNameId, classPK, friendlyURL);
181    
182                    Group group = groupPersistence.create(groupId);
183    
184                    group.setCompanyId(user.getCompanyId());
185                    group.setCreatorUserId(userId);
186                    group.setClassNameId(classNameId);
187                    group.setClassPK(classPK);
188                    group.setParentGroupId(parentGroupId);
189                    group.setLiveGroupId(liveGroupId);
190                    group.setName(name);
191                    group.setDescription(description);
192                    group.setType(type);
193                    group.setFriendlyURL(friendlyURL);
194                    group.setActive(active);
195    
196                    groupPersistence.update(group, false);
197    
198                    // Layout sets
199    
200                    layoutSetLocalService.addLayoutSet(groupId, true);
201    
202                    layoutSetLocalService.addLayoutSet(groupId, false);
203    
204                    if ((classNameId == groupClassNameId) && !user.isDefaultUser()) {
205    
206                            // Resources
207    
208                            resourceLocalService.addResources(
209                                    group.getCompanyId(), 0, 0, Group.class.getName(),
210                                    group.getGroupId(), false, false, false);
211    
212                            // Community roles
213    
214                            Role role = roleLocalService.getRole(
215                                    group.getCompanyId(), RoleConstants.COMMUNITY_OWNER);
216    
217                            userGroupRoleLocalService.addUserGroupRoles(
218                                    userId, groupId, new long[] {role.getRoleId()});
219    
220                            // User
221    
222                            userLocalService.addGroupUsers(
223                                    group.getGroupId(), new long[] {userId});
224    
225                            // Asset
226    
227                            if (serviceContext != null) {
228                                    updateAsset(
229                                            userId, group, serviceContext.getAssetCategoryIds(),
230                                            serviceContext.getAssetTagNames());
231                            }
232                    }
233                    else if (className.equals(Organization.class.getName()) &&
234                                     !user.isDefaultUser()) {
235    
236                            // Resources
237    
238                            resourceLocalService.addResources(
239                                    group.getCompanyId(), 0, 0, Group.class.getName(),
240                                    group.getGroupId(), false, false, false);
241                    }
242    
243                    return group;
244            }
245    
246            public void addRoleGroups(long roleId, long[] groupIds)
247                    throws SystemException {
248    
249                    rolePersistence.addGroups(roleId, groupIds);
250    
251                    PermissionCacheUtil.clearCache();
252            }
253    
254            public void addUserGroups(long userId, long[] groupIds)
255                    throws SystemException {
256    
257                    userPersistence.addGroups(userId, groupIds);
258    
259                    PermissionCacheUtil.clearCache();
260            }
261    
262            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
263            public void checkCompanyGroup(long companyId)
264                    throws PortalException, SystemException {
265    
266                    long classNameId = PortalUtil.getClassNameId(Company.class);
267    
268                    int count = groupPersistence.countByC_C_C(
269                            companyId, classNameId, companyId);
270    
271                    if (count == 0) {
272                            long defaultUserId = userLocalService.getDefaultUserId(companyId);
273    
274                            groupLocalService.addGroup(
275                                    defaultUserId, Company.class.getName(), companyId, null, null,
276                                    0, null, true, null);
277                    }
278            }
279    
280            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
281            public void checkSystemGroups(long companyId)
282                    throws PortalException, SystemException {
283    
284                    for (Group group : groupFinder.findBySystem(companyId)) {
285                            _systemGroupsMap.put(companyId + group.getName(), group);
286                    }
287    
288                    long defaultUserId = userLocalService.getDefaultUserId(companyId);
289    
290                    String[] systemGroups = PortalUtil.getSystemGroups();
291    
292                    for (String name : systemGroups) {
293                            Group group = _systemGroupsMap.get(companyId + name);
294    
295                            try {
296                                    if (group == null) {
297                                            group = groupPersistence.findByC_N(companyId, name);
298                                    }
299                            }
300                            catch (NoSuchGroupException nsge) {
301                                    int type = GroupConstants.TYPE_COMMUNITY_OPEN;
302                                    String friendlyURL = null;
303    
304                                    if (name.equals(GroupConstants.CONTROL_PANEL)) {
305                                            type = GroupConstants.TYPE_COMMUNITY_PRIVATE;
306                                            friendlyURL = GroupConstants.CONTROL_PANEL_FRIENDLY_URL;
307                                    }
308                                    else if (name.equals(GroupConstants.GUEST)) {
309                                            friendlyURL = "/guest";
310                                    }
311    
312                                    group = groupLocalService.addGroup(
313                                            defaultUserId, null, 0, name, null, type, friendlyURL,
314                                            true, null);
315                            }
316    
317                            if (group.isControlPanel()) {
318                                    LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
319                                            group.getGroupId(), true);
320    
321                                    if (layoutSet.getPageCount() == 0) {
322                                            addControlPanelLayouts(group);
323                                    }
324                            }
325    
326                            if (group.getName().equals(GroupConstants.GUEST)) {
327                                    LayoutSet layoutSet = layoutSetLocalService.getLayoutSet(
328                                            group.getGroupId(), false);
329    
330                                    if (layoutSet.getPageCount() == 0) {
331                                            addDefaultGuestPublicLayouts(group);
332                                    }
333                            }
334    
335                            _systemGroupsMap.put(companyId + name, group);
336                    }
337            }
338    
339            public void deleteGroup(long groupId)
340                    throws PortalException, SystemException {
341    
342                    Group group = groupPersistence.findByPrimaryKey(groupId);
343    
344                    if (PortalUtil.isSystemGroup(group.getName())) {
345                            throw new RequiredGroupException(String.valueOf(groupId));
346                    }
347    
348                    // Layout sets
349    
350                    try {
351                            layoutSetLocalService.deleteLayoutSet(groupId, true);
352                    }
353                    catch (NoSuchLayoutSetException nslse) {
354                    }
355    
356                    try {
357                            layoutSetLocalService.deleteLayoutSet(groupId, false);
358                    }
359                    catch (NoSuchLayoutSetException nslse) {
360                    }
361    
362                    // Group roles
363    
364                    userGroupRoleLocalService.deleteUserGroupRolesByGroupId(groupId);
365    
366                    // User group roles
367    
368                    userGroupGroupRoleLocalService.deleteUserGroupGroupRolesByGroupId(
369                            groupId);
370    
371                    // Membership requests
372    
373                    membershipRequestLocalService.deleteMembershipRequests(
374                            group.getGroupId());
375    
376                    // Subscriptions
377    
378                    subscriptionLocalService.deleteSubscriptions(
379                            group.getCompanyId(), BlogsEntry.class.getName(),
380                            group.getGroupId());
381                    subscriptionLocalService.deleteSubscriptions(
382                            group.getCompanyId(), JournalArticle.class.getName(),
383                            group.getGroupId());
384    
385                    /// Teams
386    
387                    teamLocalService.deleteTeams(group.getGroupId());
388    
389                    // Staging
390    
391                    unscheduleStaging(group);
392    
393                    if (group.hasStagingGroup()) {
394                            deleteGroup(group.getStagingGroup().getGroupId());
395                    }
396    
397                    // Asset
398    
399                    if (group.isCommunity()) {
400                            assetEntryLocalService.deleteEntry(Group.class.getName(), groupId);
401                    }
402    
403                    // Blogs
404    
405                    blogsEntryLocalService.deleteEntries(groupId);
406                    blogsStatsUserLocalService.deleteStatsUserByGroupId(groupId);
407    
408                    // Bookmarks
409    
410                    bookmarksFolderLocalService.deleteFolders(groupId);
411    
412                    // Calendar
413    
414                    calEventLocalService.deleteEvents(groupId);
415    
416                    // Document library
417    
418                    dlFolderLocalService.deleteFolders(groupId);
419    
420                    // Image gallery
421    
422                    igFolderLocalService.deleteFolders(groupId);
423    
424                    // Journal
425    
426                    journalArticleLocalService.deleteArticles(groupId);
427                    journalTemplateLocalService.deleteTemplates(groupId);
428                    journalStructureLocalService.deleteStructures(groupId);
429    
430                    // Message boards
431    
432                    mbBanLocalService.deleteBansByGroupId(groupId);
433                    mbCategoryLocalService.deleteCategories(groupId);
434                    mbStatsUserLocalService.deleteStatsUsersByGroupId(groupId);
435    
436                    // Polls
437    
438                    pollsQuestionLocalService.deleteQuestions(groupId);
439    
440                    // Shopping
441    
442                    shoppingCartLocalService.deleteGroupCarts(groupId);
443                    shoppingCategoryLocalService.deleteCategories(groupId);
444                    shoppingCouponLocalService.deleteCoupons(groupId);
445                    shoppingOrderLocalService.deleteOrders(groupId);
446    
447                    // Software catalog
448    
449                    scFrameworkVersionLocalService.deleteFrameworkVersions(groupId);
450                    scProductEntryLocalService.deleteProductEntries(groupId);
451    
452                    // Wiki
453    
454                    wikiNodeLocalService.deleteNodes(groupId);
455    
456                    // Resources
457    
458                    Iterator<Resource> itr = resourceFinder.findByC_P(
459                            group.getCompanyId(), String.valueOf(groupId)).iterator();
460    
461                    while (itr.hasNext()) {
462                            Resource resource = itr.next();
463    
464                            resourceLocalService.deleteResource(resource);
465                    }
466    
467                    if (!group.isStagingGroup() &&
468                            (group.isCommunity() || group.isOrganization())) {
469    
470                            resourceLocalService.deleteResource(
471                                    group.getCompanyId(), Group.class.getName(),
472                                    ResourceConstants.SCOPE_INDIVIDUAL, group.getGroupId());
473                    }
474    
475                    // Group
476    
477                    groupPersistence.remove(group);
478    
479                    // Permission cache
480    
481                    PermissionCacheUtil.clearCache();
482            }
483    
484            public Group getCompanyGroup(long companyId)
485                    throws PortalException, SystemException {
486    
487                    long classNameId = PortalUtil.getClassNameId(Company.class);
488    
489                    return groupPersistence.findByC_C_C(companyId, classNameId, companyId);
490            }
491    
492            public List<Group> getCompanyGroups(long companyId, int start, int end)
493                    throws SystemException {
494    
495                    return groupPersistence.findByCompanyId(companyId, start, end);
496            }
497    
498            public int getCompanyGroupsCount(long companyId) throws SystemException {
499                    return groupPersistence.countByCompanyId(companyId);
500            }
501    
502            public Group getFriendlyURLGroup(long companyId, String friendlyURL)
503                    throws PortalException, SystemException {
504    
505                    if (Validator.isNull(friendlyURL)) {
506                            throw new NoSuchGroupException();
507                    }
508    
509                    friendlyURL = getFriendlyURL(friendlyURL);
510    
511                    return groupPersistence.findByC_F(companyId, friendlyURL);
512            }
513    
514            public Group getGroup(long groupId)
515                    throws PortalException, SystemException {
516    
517                    return groupPersistence.findByPrimaryKey(groupId);
518            }
519    
520            public Group getGroup(long companyId, String name)
521                    throws PortalException, SystemException {
522    
523                    Group group = _systemGroupsMap.get(companyId + name);
524    
525                    if (group != null) {
526                            return group;
527                    }
528    
529                    return groupPersistence.findByC_N(companyId, name);
530            }
531    
532            public List<Group> getGroups(long[] groupIds)
533                    throws PortalException, SystemException {
534    
535                    List<Group> groups = new ArrayList<Group>(groupIds.length);
536    
537                    for (long groupId : groupIds) {
538                            Group group = getGroup(groupId);
539    
540                            groups.add(group);
541                    }
542    
543                    return groups;
544            }
545    
546            public Group getLayoutGroup(long companyId, long plid)
547                    throws PortalException, SystemException {
548    
549                    long classNameId = PortalUtil.getClassNameId(Layout.class);
550    
551                    return groupPersistence.findByC_C_C(companyId, classNameId, plid);
552            }
553    
554            public Group getLayoutPrototypeGroup(long companyId, long layoutPrototypeId)
555                    throws PortalException, SystemException {
556    
557                    long classNameId = PortalUtil.getClassNameId(LayoutPrototype.class);
558    
559                    return groupPersistence.findByC_C_C(
560                            companyId, classNameId, layoutPrototypeId);
561            }
562    
563            public Group getLayoutSetPrototypeGroup(
564                            long companyId, long layoutSetPrototypeId)
565                    throws PortalException, SystemException {
566    
567                    long classNameId = PortalUtil.getClassNameId(LayoutSetPrototype.class);
568    
569                    return groupPersistence.findByC_C_C(
570                            companyId, classNameId, layoutSetPrototypeId);
571            }
572    
573            public List<Group> getLiveGroups() throws SystemException {
574                    return groupFinder.findByLiveGroups();
575            }
576    
577            public List<Group> getNoLayoutsGroups(
578                            String className, boolean privateLayout, int start, int end)
579                    throws SystemException {
580    
581                    long classNameId = PortalUtil.getClassNameId(className);
582    
583                    return groupFinder.findByNoLayouts(
584                            classNameId, privateLayout, start, end);
585            }
586    
587            public List<Group> getNullFriendlyURLGroups() throws SystemException {
588                    return groupFinder.findByNullFriendlyURL();
589            }
590    
591            public Group getOrganizationGroup(long companyId, long organizationId)
592                    throws PortalException, SystemException {
593    
594                    long classNameId = PortalUtil.getClassNameId(Organization.class);
595    
596                    return groupPersistence.findByC_C_C(
597                            companyId, classNameId, organizationId);
598            }
599    
600            public List<Group> getOrganizationsGroups(
601                    List<Organization> organizations) {
602    
603                    List<Group> organizationGroups = new ArrayList<Group>();
604    
605                    for (int i = 0; i < organizations.size(); i++) {
606                            Organization organization = organizations.get(i);
607    
608                            Group group = organization.getGroup();
609    
610                            organizationGroups.add(group);
611                    }
612    
613                    return organizationGroups;
614            }
615    
616            public List<Group> getOrganizationsRelatedGroups(
617                            List<Organization> organizations)
618                    throws SystemException {
619    
620                    List<Group> organizationGroups = new ArrayList<Group>();
621    
622                    for (int i = 0; i < organizations.size(); i++) {
623                            Organization organization = organizations.get(i);
624    
625                            List<Group> groups = organizationPersistence.getGroups(
626                                    organization.getOrganizationId());
627    
628                            organizationGroups.addAll(groups);
629                    }
630    
631                    return organizationGroups;
632            }
633    
634            public List<Group> getRoleGroups(long roleId) throws SystemException {
635                    return rolePersistence.getGroups(roleId);
636            }
637    
638            public Group getStagingGroup(long liveGroupId)
639                    throws PortalException, SystemException {
640    
641                    return groupPersistence.findByLiveGroupId(liveGroupId);
642            }
643    
644            public Group getUserGroup(long companyId, long userId)
645                    throws PortalException, SystemException {
646    
647                    long classNameId = PortalUtil.getClassNameId(User.class);
648    
649                    return groupPersistence.findByC_C_C(companyId, classNameId, userId);
650            }
651    
652            public Group getUserGroupGroup(long companyId, long userGroupId)
653                    throws PortalException, SystemException {
654    
655                    long classNameId = PortalUtil.getClassNameId(UserGroup.class);
656    
657                    return groupPersistence.findByC_C_C(
658                            companyId, classNameId, userGroupId);
659            }
660    
661            public List<Group> getUserGroups(long userId)
662                    throws PortalException, SystemException {
663    
664                    return getUserGroups(userId, false);
665            }
666    
667            public List<Group> getUserGroups(long userId, boolean inherit)
668                    throws PortalException, SystemException {
669    
670                    return getUserGroups(
671                            userId, inherit, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
672            }
673    
674            public List<Group> getUserGroups(long userId, int start, int end)
675                    throws PortalException, SystemException {
676    
677                    return getUserGroups(userId, false, start, end);
678            }
679    
680            public List<Group> getUserGroups(
681                            long userId, boolean inherit, int start, int end)
682                    throws PortalException, SystemException {
683    
684                    if (inherit) {
685                            User user = userPersistence.findByPrimaryKey(userId);
686    
687                            LinkedHashMap<String, Object> groupParams =
688                                    new LinkedHashMap<String, Object>();
689    
690                            groupParams.put("usersGroups", new Long(userId));
691    
692                            return search(
693                                    user.getCompanyId(), null, null, groupParams, start, end);
694                    }
695                    else {
696                            return userPersistence.getGroups(userId);
697                    }
698            }
699    
700            public List<Group> getUserGroupsGroups(List<UserGroup> userGroups)
701                    throws PortalException, SystemException {
702    
703                    List<Group> userGroupGroups = new ArrayList<Group>();
704    
705                    for (int i = 0; i < userGroups.size(); i++) {
706                            UserGroup userGroup = userGroups.get(i);
707    
708                            Group group = userGroup.getGroup();
709    
710                            userGroupGroups.add(group);
711                    }
712    
713                    return userGroupGroups;
714            }
715    
716            public List<Group> getUserGroupsRelatedGroups(List<UserGroup> userGroups)
717                    throws SystemException {
718    
719                    List<Group> userGroupGroups = new ArrayList<Group>();
720    
721                    for (int i = 0; i < userGroups.size(); i++) {
722                            UserGroup userGroup = userGroups.get(i);
723    
724                            List<Group> groups = userGroupPersistence.getGroups(
725                                    userGroup.getUserGroupId());
726    
727                            userGroupGroups.addAll(groups);
728                    }
729    
730                    return userGroupGroups;
731            }
732    
733            public List<Group> getUserOrganizationsGroups(
734                            long userId, int start, int end)
735                    throws PortalException, SystemException {
736    
737                    List<Group> userOrgsGroups = new UniqueList<Group>();
738    
739                    List<Organization> userOrgs =
740                            organizationLocalService.getUserOrganizations(
741                                    userId, true, start, end);
742    
743                    for (Organization organization : userOrgs) {
744                            userOrgsGroups.add(0, organization.getGroup());
745    
746                            if (!PropsValues.ORGANIZATIONS_MEMBERSHIP_STRICT) {
747                                    for (Organization ancestorOrganization :
748                                                    organization.getAncestors()) {
749    
750                                            userOrgsGroups.add(0, ancestorOrganization.getGroup());
751                                    }
752                            }
753                    }
754    
755                    return userOrgsGroups;
756            }
757    
758            public boolean hasRoleGroup(long roleId, long groupId)
759                    throws SystemException {
760    
761                    return rolePersistence.containsGroup(roleId, groupId);
762            }
763    
764            public boolean hasStagingGroup(long liveGroupId) throws SystemException {
765                    if (groupPersistence.fetchByLiveGroupId(liveGroupId) != null) {
766                            return true;
767                    }
768                    else {
769                            return false;
770                    }
771            }
772    
773            public boolean hasUserGroup(long userId, long groupId)
774                    throws SystemException {
775    
776                    if (groupFinder.countByG_U(groupId, userId) > 0) {
777                            return true;
778                    }
779                    else {
780                            return false;
781                    }
782            }
783    
784            public List<Group> search(
785                            long companyId, long[] classNameIds, String name,
786                            String description,     LinkedHashMap<String, Object> params, int start,
787                            int end)
788                    throws SystemException {
789    
790                    return search(
791                            companyId, classNameIds, name, description, params, start, end,
792                            null);
793            }
794    
795            public List<Group> search(
796                            long companyId, long[] classNameIds, String name,
797                            String description, LinkedHashMap<String, Object> params, int start,
798                            int end, OrderByComparator obc)
799                    throws SystemException {
800    
801                    if (obc == null) {
802                            obc = new GroupNameComparator(true);
803                    }
804    
805                    String realName = getRealName(companyId, name);
806    
807                    return groupFinder.findByC_C_N_D(
808                            companyId, classNameIds, name, realName, description, params, start,
809                            end, obc);
810            }
811    
812            public List<Group> search(
813                            long companyId, String name, String description,
814                            LinkedHashMap<String, Object> params, int start, int end)
815                    throws SystemException {
816    
817                    return search(companyId, name, description, params, start, end, null);
818            }
819    
820            public List<Group> search(
821                            long companyId, String name, String description,
822                            LinkedHashMap<String, Object> params, int start, int end,
823                            OrderByComparator obc)
824                    throws SystemException {
825    
826                    if (obc == null) {
827                            obc = new GroupNameComparator(true);
828                    }
829    
830                    String realName = getRealName(companyId, name);
831    
832                    return groupFinder.findByC_N_D(
833                            companyId, name, realName, description, params, start, end, obc);
834            }
835    
836            @ThreadLocalCachable
837            public int searchCount(
838                            long companyId, String name, String description,
839                            LinkedHashMap<String, Object> params)
840                    throws SystemException {
841    
842                    String realName = getRealName(companyId, name);
843    
844                    return groupFinder.countByC_N_D(
845                            companyId, name, realName, description, params);
846            }
847    
848            @ThreadLocalCachable
849            public int searchCount(
850                            long companyId, long[] classNameIds, String name,
851                            String description, LinkedHashMap<String, Object> params)
852                    throws SystemException {
853    
854                    String realName = getRealName(companyId, name);
855    
856                    return groupFinder.countByC_C_N_D(
857                            companyId, classNameIds, name, realName, description, params);
858            }
859    
860            public void setRoleGroups(long roleId, long[] groupIds)
861                    throws SystemException {
862    
863                    rolePersistence.setGroups(roleId, groupIds);
864    
865                    PermissionCacheUtil.clearCache();
866            }
867    
868            public void unsetRoleGroups(long roleId, long[] groupIds)
869                    throws SystemException {
870    
871                    rolePersistence.removeGroups(roleId, groupIds);
872    
873                    PermissionCacheUtil.clearCache();
874            }
875    
876            public void unsetUserGroups(long userId, long[] groupIds)
877                    throws SystemException {
878    
879                    userGroupRoleLocalService.deleteUserGroupRoles(userId, groupIds);
880    
881                    userPersistence.removeGroups(userId, groupIds);
882    
883                    PermissionCacheUtil.clearCache();
884            }
885    
886            public void updateAsset(
887                            long userId, Group group, long[] assetCategoryIds,
888                            String[] assetTagNames)
889                    throws PortalException, SystemException {
890    
891                    User user = userPersistence.findByPrimaryKey(userId);
892    
893                    Company company = companyPersistence.findByPrimaryKey(
894                            user.getCompanyId());
895    
896                    Group companyGroup = company.getGroup();
897    
898                    assetEntryLocalService.updateEntry(
899                            userId, companyGroup.getGroupId(), Group.class.getName(),
900                            group.getGroupId(), null, assetCategoryIds, assetTagNames, false,
901                            null, null, null, null, null, group.getDescriptiveName(),
902                            group.getDescription(), null, null, 0, 0, null, false);
903            }
904    
905            public Group updateFriendlyURL(long groupId, String friendlyURL)
906                    throws PortalException, SystemException {
907    
908                    Group group = groupPersistence.findByPrimaryKey(groupId);
909    
910                    if (group.isUser()) {
911                            User user = userPersistence.findByPrimaryKey(group.getClassPK());
912    
913                            friendlyURL = StringPool.SLASH + user.getScreenName();
914    
915                            if (group.getFriendlyURL().equals(friendlyURL)) {
916                                    return group;
917                            }
918                    }
919    
920                    friendlyURL = getFriendlyURL(
921                            group.getCompanyId(), groupId, group.getClassNameId(),
922                            group.getClassPK(), StringPool.BLANK, friendlyURL);
923    
924                    validateFriendlyURL(
925                            group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
926                            group.getClassPK(), friendlyURL);
927    
928                    group.setFriendlyURL(friendlyURL);
929    
930                    groupPersistence.update(group, false);
931    
932                    return group;
933            }
934    
935            public Group updateGroup(
936                            long groupId, String name, String description, int type,
937                            String friendlyURL, boolean active, ServiceContext serviceContext)
938                    throws PortalException, SystemException {
939    
940                    Group group = groupPersistence.findByPrimaryKey(groupId);
941    
942                    String className = group.getClassName();
943                    long classNameId = group.getClassNameId();
944                    long classPK = group.getClassPK();
945                    friendlyURL = getFriendlyURL(
946                            group.getCompanyId(), groupId, classNameId, classPK,
947                            StringPool.BLANK, friendlyURL);
948    
949                    if ((classNameId <= 0) || className.equals(Group.class.getName())) {
950                            validateName(group.getGroupId(), group.getCompanyId(), name);
951                    }
952                    else {
953                            name = String.valueOf(classPK);
954                    }
955    
956                    if (PortalUtil.isSystemGroup(group.getName()) &&
957                            !group.getName().equals(name)) {
958    
959                            throw new RequiredGroupException();
960                    }
961    
962                    validateFriendlyURL(
963                            group.getCompanyId(), group.getGroupId(), group.getClassNameId(),
964                            group.getClassPK(), friendlyURL);
965    
966                    group.setName(name);
967                    group.setDescription(description);
968                    group.setType(type);
969                    group.setFriendlyURL(friendlyURL);
970                    group.setActive(active);
971    
972                    groupPersistence.update(group, false);
973    
974                    // Asset
975    
976                    if ((serviceContext != null) && group.isCommunity()) {
977                            User user = null;
978    
979                            try {
980                                    user = userPersistence.findByPrimaryKey(
981                                            group.getCreatorUserId());
982    
983                            }
984                            catch (NoSuchUserException nsue1) {
985                                    try {
986                                            user = userPersistence.findByPrimaryKey(
987                                                    serviceContext.getUserId());
988                                    }
989                                    catch (NoSuchUserException nsue2) {
990                                            user = userLocalService.getDefaultUser(
991                                                    group.getCompanyId());
992                                    }
993                            }
994    
995                            updateAsset(
996                                    user.getUserId(), group, serviceContext.getAssetCategoryIds(),
997                                    serviceContext.getAssetTagNames());
998                    }
999    
1000                    return group;
1001            }
1002    
1003            public Group updateGroup(long groupId, String typeSettings)
1004                    throws PortalException, SystemException {
1005    
1006                    Group group = groupPersistence.findByPrimaryKey(groupId);
1007    
1008                    group.setTypeSettings(typeSettings);
1009    
1010                    groupPersistence.update(group, false);
1011    
1012                    return group;
1013            }
1014    
1015            public Group updateWorkflow(
1016                            long groupId, boolean workflowEnabled, int workflowStages,
1017                            String workflowRoleNames)
1018                    throws PortalException, SystemException {
1019    
1020                    Group group = groupPersistence.findByPrimaryKey(groupId);
1021    
1022                    UnicodeProperties props = group.getTypeSettingsProperties();
1023    
1024                    props.setProperty("workflowEnabled", String.valueOf(workflowEnabled));
1025    
1026                    if (workflowEnabled) {
1027                            if (workflowStages < PropsValues.TASKS_DEFAULT_STAGES) {
1028                                    workflowStages = PropsValues.TASKS_DEFAULT_STAGES;
1029                            }
1030    
1031                            if (Validator.isNull(workflowRoleNames)) {
1032                                    workflowRoleNames = PropsValues.TASKS_DEFAULT_ROLE_NAMES;
1033                            }
1034    
1035                            props.setProperty("workflowStages", String.valueOf(workflowStages));
1036                            props.setProperty("workflowRoleNames", workflowRoleNames);
1037                    }
1038    
1039                    group.setTypeSettings(group.getTypeSettings());
1040    
1041                    groupPersistence.update(group, false);
1042    
1043                    if (!workflowEnabled) {
1044                            tasksProposalLocalService.deleteProposals(groupId);
1045                    }
1046    
1047                    return group;
1048            }
1049    
1050            protected void addControlPanelLayouts(Group group)
1051                    throws PortalException, SystemException {
1052    
1053                    long defaultUserId = userLocalService.getDefaultUserId(
1054                            group.getCompanyId());
1055    
1056                    String friendlyURL = getFriendlyURL(
1057                            PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
1058    
1059                    ServiceContext serviceContext = new ServiceContext();
1060    
1061                    layoutLocalService.addLayout(
1062                            defaultUserId, group.getGroupId(), true,
1063                            LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
1064                            PropsValues.CONTROL_PANEL_LAYOUT_NAME, StringPool.BLANK,
1065                            StringPool.BLANK, LayoutConstants.TYPE_CONTROL_PANEL, false,
1066                            friendlyURL, serviceContext);
1067            }
1068    
1069            protected void addDefaultGuestPublicLayoutByProperties(Group group)
1070                    throws PortalException, SystemException {
1071    
1072                    long defaultUserId = userLocalService.getDefaultUserId(
1073                            group.getCompanyId());
1074                    String friendlyURL = getFriendlyURL(
1075                            PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_FRIENDLY_URL);
1076    
1077                    ServiceContext serviceContext = new ServiceContext();
1078    
1079                    Layout layout = layoutLocalService.addLayout(
1080                            defaultUserId, group.getGroupId(), false,
1081                            LayoutConstants.DEFAULT_PARENT_LAYOUT_ID,
1082                            PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_NAME, StringPool.BLANK,
1083                            StringPool.BLANK, LayoutConstants.TYPE_PORTLET, false, friendlyURL,
1084                            serviceContext);
1085    
1086                    LayoutTypePortlet layoutTypePortlet =
1087                            (LayoutTypePortlet)layout.getLayoutType();
1088    
1089                    layoutTypePortlet.setLayoutTemplateId(
1090                            0, PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_TEMPLATE_ID, false);
1091    
1092                    for (int i = 0; i < 10; i++) {
1093                            String columnId = "column-" + i;
1094                            String portletIds = PropsUtil.get(
1095                                    PropsKeys.DEFAULT_GUEST_PUBLIC_LAYOUT_COLUMN + i);
1096    
1097                            layoutTypePortlet.addPortletIds(
1098                                    0, StringUtil.split(portletIds), columnId, false);
1099                    }
1100    
1101                    layoutLocalService.updateLayout(
1102                            layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
1103                            layout.getTypeSettings());
1104    
1105                    boolean updateLayoutSet = false;
1106    
1107                    LayoutSet layoutSet = layout.getLayoutSet();
1108    
1109                    if (Validator.isNotNull(
1110                                    PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID)) {
1111    
1112                            layoutSet.setThemeId(
1113                                    PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_THEME_ID);
1114    
1115                            updateLayoutSet = true;
1116                    }
1117    
1118                    if (Validator.isNotNull(
1119                                    PropsValues.
1120                                            DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID)) {
1121    
1122                            layoutSet.setColorSchemeId(
1123                                    PropsValues.
1124                                            DEFAULT_GUEST_PUBLIC_LAYOUT_REGULAR_COLOR_SCHEME_ID);
1125    
1126                            updateLayoutSet = true;
1127                    }
1128    
1129                    if (Validator.isNotNull(
1130                                    PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID)) {
1131    
1132                            layoutSet.setWapThemeId(
1133                                    PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_THEME_ID);
1134    
1135                            updateLayoutSet = true;
1136                    }
1137    
1138                    if (Validator.isNotNull(
1139                                    PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID)) {
1140    
1141                            layoutSet.setWapColorSchemeId(
1142                                    PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUT_WAP_COLOR_SCHEME_ID);
1143    
1144                            updateLayoutSet = true;
1145                    }
1146    
1147                    if (updateLayoutSet) {
1148                            layoutSetLocalService.updateLayoutSet(layoutSet);
1149                    }
1150            }
1151    
1152            protected void addDefaultGuestPublicLayouts(Group group)
1153                    throws PortalException, SystemException {
1154    
1155                    if (publicLARFile != null) {
1156                            addDefaultGuestPublicLayoutsByLAR(group, publicLARFile);
1157                    }
1158                    else {
1159                            addDefaultGuestPublicLayoutByProperties(group);
1160                    }
1161            }
1162    
1163            protected void addDefaultGuestPublicLayoutsByLAR(Group group, File larFile)
1164                    throws PortalException, SystemException {
1165    
1166                    long defaultUserId = userLocalService.getDefaultUserId(
1167                            group.getCompanyId());
1168    
1169                    Map<String, String[]> parameterMap = new HashMap<String, String[]>();
1170    
1171                    parameterMap.put(
1172                            PortletDataHandlerKeys.CATEGORIES,
1173                            new String[] {Boolean.TRUE.toString()});
1174                    parameterMap.put(
1175                            PortletDataHandlerKeys.PERMISSIONS,
1176                            new String[] {Boolean.TRUE.toString()});
1177                    parameterMap.put(
1178                            PortletDataHandlerKeys.PORTLET_DATA,
1179                            new String[] {Boolean.TRUE.toString()});
1180                    parameterMap.put(
1181                            PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT,
1182                            new String[] {Boolean.TRUE.toString()});
1183                    parameterMap.put(
1184                            PortletDataHandlerKeys.PORTLET_SETUP,
1185                            new String[] {Boolean.TRUE.toString()});
1186                    parameterMap.put(
1187                            PortletDataHandlerKeys.USER_PERMISSIONS,
1188                            new String[] {Boolean.FALSE.toString()});
1189    
1190                    layoutLocalService.importLayouts(
1191                            defaultUserId, group.getGroupId(), false, parameterMap, larFile);
1192            }
1193    
1194            protected String getFriendlyURL(String friendlyURL) {
1195                    return FriendlyURLNormalizer.normalize(friendlyURL);
1196            }
1197    
1198            protected String getFriendlyURL(
1199                            long companyId, long groupId, long classNameId, long classPK,
1200                            String friendlyName, String friendlyURL)
1201                    throws PortalException, SystemException {
1202    
1203                    friendlyURL = getFriendlyURL(friendlyURL);
1204    
1205                    if (Validator.isNull(friendlyURL)) {
1206                            friendlyURL = StringPool.SLASH + getFriendlyURL(friendlyName);
1207    
1208                            String originalFriendlyURL = friendlyURL;
1209    
1210                            for (int i = 1;; i++) {
1211                                    try {
1212                                            validateFriendlyURL(
1213                                                    companyId, groupId, classNameId, classPK, friendlyURL);
1214    
1215                                            break;
1216                                    }
1217                                    catch (GroupFriendlyURLException gfurle) {
1218                                            int type = gfurle.getType();
1219    
1220                                            if (type == GroupFriendlyURLException.DUPLICATE) {
1221                                                    friendlyURL = originalFriendlyURL + i;
1222                                            }
1223                                            else {
1224                                                    friendlyURL = StringPool.SLASH + classPK;
1225    
1226                                                    break;
1227                                            }
1228                                    }
1229                            }
1230                    }
1231    
1232                    return friendlyURL;
1233            }
1234    
1235            protected String getRealName(long companyId, String name)
1236                    throws SystemException {
1237    
1238                    if (Validator.isNull(name)) {
1239                            return name;
1240                    }
1241    
1242                    String realName = name;
1243    
1244                    try {
1245                            Company company = companyLocalService.getCompany(companyId);
1246    
1247                            Account account = company.getAccount();
1248    
1249                            String companyName = account.getName();
1250    
1251                            name = StringUtil.replace(
1252                                    name, StringPool.PERCENT, StringPool.BLANK);
1253    
1254                            if (companyName.indexOf(name) != -1) {
1255                                    realName = StringPool.PERCENT + GroupConstants.GUEST +
1256                                            StringPool.PERCENT;
1257                            }
1258                    }
1259                    catch (PortalException pe) {
1260                    }
1261    
1262                    return realName;
1263            }
1264    
1265            protected boolean isStaging(ServiceContext serviceContext) {
1266                    if (serviceContext != null) {
1267                            return ParamUtil.getBoolean(serviceContext, "staging");
1268                    }
1269    
1270                    return false;
1271            }
1272    
1273            protected void initImportLARFile() {
1274                    String publicLARFileName = PropsValues.DEFAULT_GUEST_PUBLIC_LAYOUTS_LAR;
1275    
1276                    if (_log.isDebugEnabled()) {
1277                            _log.debug("Reading public LAR file " + publicLARFileName);
1278                    }
1279    
1280                    if (Validator.isNotNull(publicLARFileName)) {
1281                            publicLARFile = new File(publicLARFileName);
1282    
1283                            if (!publicLARFile.exists()) {
1284                                    _log.error(
1285                                            "Public LAR file " + publicLARFile + " does not exist");
1286    
1287                                    publicLARFile = null;
1288                            }
1289                            else {
1290                                    if (_log.isDebugEnabled()) {
1291                                            _log.debug("Using public LAR file " + publicLARFileName);
1292                                    }
1293                            }
1294                    }
1295            }
1296    
1297            protected void unscheduleStaging(Group group) {
1298                    try {
1299    
1300                            // Remote publishing
1301    
1302                            String groupName = StagingUtil.getSchedulerGroupName(
1303                                    DestinationNames.LAYOUTS_REMOTE_PUBLISHER, group.getGroupId());
1304    
1305                            List<SchedulerRequest> schedulerRequests =
1306                                    SchedulerEngineUtil.getScheduledJobs(groupName);
1307    
1308                            for (SchedulerRequest schedulerRequest : schedulerRequests) {
1309                                    SchedulerEngineUtil.unschedule(schedulerRequest.getTrigger());
1310                            }
1311    
1312                            long liveGroupId = 0;
1313                            long stagingGroupId = 0;
1314    
1315                            if (group.isStagingGroup()) {
1316                                    liveGroupId = group.getLiveGroupId();
1317    
1318                                    stagingGroupId = group.getGroupId();
1319                            }
1320                            else if (group.hasStagingGroup()) {
1321                                    liveGroupId = group.getGroupId();
1322    
1323                                    stagingGroupId = group.getStagingGroup().getGroupId();
1324                            }
1325    
1326                            if ((liveGroupId != 0) && (stagingGroupId != 0)) {
1327    
1328                                    // Publish to live
1329    
1330                                    groupName = StagingUtil.getSchedulerGroupName(
1331                                            DestinationNames.LAYOUTS_LOCAL_PUBLISHER, liveGroupId);
1332    
1333                                    schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
1334                                            groupName);
1335    
1336                                    for (SchedulerRequest schedulerRequest : schedulerRequests) {
1337                                            SchedulerEngineUtil.unschedule(
1338                                                    schedulerRequest.getTrigger());
1339                                    }
1340    
1341                                    // Copy from live
1342    
1343                                    groupName = StagingUtil.getSchedulerGroupName(
1344                                            DestinationNames.LAYOUTS_LOCAL_PUBLISHER, stagingGroupId);
1345    
1346                                    schedulerRequests = SchedulerEngineUtil.getScheduledJobs(
1347                                            groupName);
1348    
1349                                    for (SchedulerRequest schedulerRequest : schedulerRequests) {
1350                                            SchedulerEngineUtil.unschedule(
1351                                                    schedulerRequest.getTrigger());
1352                                    }
1353                            }
1354                    }
1355                    catch (Exception e) {
1356                            _log.error(
1357                                    "Unable to unschedule events for group: " + group.getGroupId());
1358                    }
1359            }
1360    
1361            protected void validateFriendlyURL(
1362                            long companyId, long groupId, long classNameId, long classPK,
1363                            String friendlyURL)
1364                    throws PortalException, SystemException {
1365    
1366                    Company company = companyPersistence.findByPrimaryKey(companyId);
1367    
1368                    if (company.isSystem()) {
1369                            return;
1370                    }
1371    
1372                    if (Validator.isNull(friendlyURL)) {
1373                            return;
1374                    }
1375    
1376                    int exceptionType = LayoutImpl.validateFriendlyURL(friendlyURL);
1377    
1378                    if (exceptionType != -1) {
1379                            throw new GroupFriendlyURLException(exceptionType);
1380                    }
1381    
1382                    Group group = groupPersistence.fetchByC_F(companyId, friendlyURL);
1383    
1384                    if ((group != null) && (group.getGroupId() != groupId)) {
1385                            throw new GroupFriendlyURLException(
1386                                    GroupFriendlyURLException.DUPLICATE);
1387                    }
1388    
1389                    String groupIdFriendlyURL = friendlyURL.substring(1);
1390    
1391                    if (Validator.isNumber(groupIdFriendlyURL)) {
1392                            long groupClassNameId = PortalUtil.getClassNameId(Group.class);
1393    
1394                            if (((classNameId != groupClassNameId) &&
1395                                     (!groupIdFriendlyURL.equals(String.valueOf(classPK))) &&
1396                                     (!PropsValues.USERS_SCREEN_NAME_ALLOW_NUMERIC)) ||
1397                                    ((classNameId == groupClassNameId) &&
1398                                     (!groupIdFriendlyURL.equals(String.valueOf(groupId))))) {
1399    
1400                                    GroupFriendlyURLException gfurle =
1401                                            new GroupFriendlyURLException(
1402                                                    GroupFriendlyURLException.POSSIBLE_DUPLICATE);
1403    
1404                                    gfurle.setKeywordConflict(groupIdFriendlyURL);
1405    
1406                                    throw gfurle;
1407                            }
1408                    }
1409    
1410                    String screenName = friendlyURL.substring(1);
1411    
1412                    User user = userPersistence.fetchByC_SN(companyId, screenName);
1413    
1414                    if (user != null) {
1415                            long userClassNameId = PortalUtil.getClassNameId(User.class);
1416    
1417                            if ((classNameId == userClassNameId) &&
1418                                    (classPK == user.getUserId())) {
1419                            }
1420                            else {
1421                                    throw new GroupFriendlyURLException(
1422                                            GroupFriendlyURLException.DUPLICATE);
1423                            }
1424                    }
1425    
1426                    if (StringUtil.count(friendlyURL, StringPool.SLASH) > 1) {
1427                            throw new GroupFriendlyURLException(
1428                                    GroupFriendlyURLException.TOO_DEEP);
1429                    }
1430            }
1431    
1432            protected void validateName(long groupId, long companyId, String name)
1433                    throws PortalException, SystemException {
1434    
1435                    if ((Validator.isNull(name)) || (Validator.isNumber(name)) ||
1436                            (name.indexOf(CharPool.STAR) != -1)) {
1437    
1438                            throw new GroupNameException();
1439                    }
1440    
1441                    try {
1442                            Group group = groupFinder.findByC_N(companyId, name);
1443    
1444                            if ((groupId <= 0) || (group.getGroupId() != groupId)) {
1445                                    throw new DuplicateGroupException();
1446                            }
1447                    }
1448                    catch (NoSuchGroupException nsge) {
1449                    }
1450            }
1451    
1452            protected File publicLARFile;
1453    
1454            private static Log _log = LogFactoryUtil.getLog(
1455                    GroupLocalServiceImpl.class);
1456    
1457            private Map<String, Group> _systemGroupsMap = new HashMap<String, Group>();
1458    
1459    }