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