001    /**
002     * Copyright (c) 2000-present 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.exception.DuplicateTeamException;
018    import com.liferay.portal.exception.TeamNameException;
019    import com.liferay.portal.kernel.dao.orm.QueryUtil;
020    import com.liferay.portal.kernel.exception.PortalException;
021    import com.liferay.portal.kernel.util.CharPool;
022    import com.liferay.portal.kernel.util.OrderByComparator;
023    import com.liferay.portal.kernel.util.Validator;
024    import com.liferay.portal.model.ResourceConstants;
025    import com.liferay.portal.model.Role;
026    import com.liferay.portal.model.RoleConstants;
027    import com.liferay.portal.model.Team;
028    import com.liferay.portal.model.User;
029    import com.liferay.portal.security.permission.PermissionCacheUtil;
030    import com.liferay.portal.service.ServiceContext;
031    import com.liferay.portal.service.base.TeamLocalServiceBaseImpl;
032    
033    import java.util.LinkedHashMap;
034    import java.util.List;
035    
036    /**
037     * @author Brian Wing Shun Chan
038     */
039    public class TeamLocalServiceImpl extends TeamLocalServiceBaseImpl {
040    
041            /**
042             * @deprecated As of 7.0.0, replaced by {@link #addTeam(long, long, String,
043             *             String, ServiceContext)}
044             */
045            @Deprecated
046            @Override
047            public Team addTeam(
048                            long userId, long groupId, String name, String description)
049                    throws PortalException {
050    
051                    return addTeam(
052                            userId, groupId, name, description, new ServiceContext());
053            }
054    
055            @Override
056            public Team addTeam(
057                            long userId, long groupId, String name, String description,
058                            ServiceContext serviceContext)
059                    throws PortalException {
060    
061                    // Team
062    
063                    User user = userPersistence.findByPrimaryKey(userId);
064    
065                    validate(0, groupId, name);
066    
067                    long teamId = counterLocalService.increment();
068    
069                    Team team = teamPersistence.create(teamId);
070    
071                    team.setUuid(serviceContext.getUuid());
072                    team.setUserId(userId);
073                    team.setCompanyId(user.getCompanyId());
074                    team.setUserName(user.getFullName());
075                    team.setGroupId(groupId);
076                    team.setName(name);
077                    team.setDescription(description);
078    
079                    teamPersistence.update(team);
080    
081                    // Resources
082    
083                    resourceLocalService.addResources(
084                            user.getCompanyId(), groupId, userId, Team.class.getName(),
085                            team.getTeamId(), false, true, true);
086    
087                    // Role
088    
089                    roleLocalService.addRole(
090                            userId, Team.class.getName(), teamId, String.valueOf(teamId), null,
091                            null, RoleConstants.TYPE_PROVIDER, null, null);
092    
093                    return team;
094            }
095    
096            @Override
097            public void addUserGroupTeam(long userGroupId, long teamId) {
098                    super.addUserGroupTeam(userGroupId, teamId);
099    
100                    PermissionCacheUtil.clearCache();
101            }
102    
103            @Override
104            public void addUserGroupTeam(long userGroupId, Team team) {
105                    super.addUserGroupTeam(userGroupId, team);
106    
107                    PermissionCacheUtil.clearCache();
108            }
109    
110            @Override
111            public void addUserGroupTeams(long userGroupId, List<Team> Teams) {
112                    super.addUserGroupTeams(userGroupId, Teams);
113    
114                    PermissionCacheUtil.clearCache();
115            }
116    
117            @Override
118            public void addUserGroupTeams(long userGroupId, long[] teamIds) {
119                    super.addUserGroupTeams(userGroupId, teamIds);
120    
121                    PermissionCacheUtil.clearCache();
122            }
123    
124            @Override
125            public void addUserTeam(long userId, long teamId) {
126                    super.addUserTeam(userId, teamId);
127    
128                    PermissionCacheUtil.clearCache(userId);
129            }
130    
131            @Override
132            public void addUserTeam(long userId, Team team) {
133                    super.addUserTeam(userId, team);
134    
135                    PermissionCacheUtil.clearCache(userId);
136            }
137    
138            @Override
139            public void addUserTeams(long userId, List<Team> Teams) {
140                    super.addUserTeams(userId, Teams);
141    
142                    PermissionCacheUtil.clearCache(userId);
143            }
144    
145            @Override
146            public void addUserTeams(long userId, long[] teamIds) {
147                    super.addUserTeams(userId, teamIds);
148    
149                    PermissionCacheUtil.clearCache(userId);
150            }
151    
152            @Override
153            public void clearUserGroupTeams(long userGroupId) {
154                    super.clearUserGroupTeams(userGroupId);
155    
156                    PermissionCacheUtil.clearCache();
157            }
158    
159            @Override
160            public void clearUserTeams(long userId) {
161                    super.clearUserTeams(userId);
162    
163                    PermissionCacheUtil.clearCache(userId);
164            }
165    
166            @Override
167            public Team deleteTeam(long teamId) throws PortalException {
168                    Team team = teamPersistence.findByPrimaryKey(teamId);
169    
170                    return deleteTeam(team);
171            }
172    
173            @Override
174            public Team deleteTeam(Team team) throws PortalException {
175    
176                    // Team
177    
178                    teamPersistence.remove(team);
179    
180                    // Resources
181    
182                    resourceLocalService.deleteResource(
183                            team.getCompanyId(), Team.class.getName(),
184                            ResourceConstants.SCOPE_INDIVIDUAL, team.getTeamId());
185    
186                    // Role
187    
188                    Role role = team.getRole();
189    
190                    roleLocalService.deleteRole(role);
191    
192                    return team;
193            }
194    
195            @Override
196            public void deleteTeams(long groupId) throws PortalException {
197                    List<Team> teams = teamPersistence.findByGroupId(groupId);
198    
199                    for (Team team : teams) {
200                            deleteTeam(team.getTeamId());
201                    }
202            }
203    
204            @Override
205            public void deleteUserGroupTeam(long userGroupId, long teamId) {
206                    super.deleteUserGroupTeam(userGroupId, teamId);
207    
208                    PermissionCacheUtil.clearCache();
209            }
210    
211            @Override
212            public void deleteUserGroupTeam(long userGroupId, Team team) {
213                    super.deleteUserGroupTeam(userGroupId, team);
214    
215                    PermissionCacheUtil.clearCache();
216            }
217    
218            @Override
219            public void deleteUserGroupTeams(long userGroupId, List<Team> Teams) {
220                    super.deleteUserGroupTeams(userGroupId, Teams);
221    
222                    PermissionCacheUtil.clearCache();
223            }
224    
225            @Override
226            public void deleteUserGroupTeams(long userGroupId, long[] teamIds) {
227                    super.deleteUserGroupTeams(userGroupId, teamIds);
228    
229                    PermissionCacheUtil.clearCache();
230            }
231    
232            @Override
233            public void deleteUserTeam(long userId, long teamId) {
234                    super.deleteUserTeam(userId, teamId);
235    
236                    PermissionCacheUtil.clearCache(userId);
237            }
238    
239            @Override
240            public void deleteUserTeam(long userId, Team team) {
241                    super.deleteUserTeam(userId, team);
242    
243                    PermissionCacheUtil.clearCache(userId);
244            }
245    
246            @Override
247            public void deleteUserTeams(long userId, List<Team> Teams) {
248                    super.deleteUserTeams(userId, Teams);
249    
250                    PermissionCacheUtil.clearCache(userId);
251            }
252    
253            @Override
254            public void deleteUserTeams(long userId, long[] teamIds) {
255                    super.deleteUserTeams(userId, teamIds);
256    
257                    PermissionCacheUtil.clearCache(userId);
258            }
259    
260            @Override
261            public Team fetchTeam(long groupId, String name) {
262                    return teamPersistence.fetchByG_N(groupId, name);
263            }
264    
265            @Override
266            public List<Team> getGroupTeams(long groupId) {
267                    return teamPersistence.findByGroupId(groupId);
268            }
269    
270            @Override
271            public Team getTeam(long groupId, String name) throws PortalException {
272                    return teamPersistence.findByG_N(groupId, name);
273            }
274    
275            @Override
276            public List<Team> getUserOrUserGroupTeams(long groupId, long userId) {
277                    return teamFinder.findByG_U(
278                            groupId, userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
279            }
280    
281            @Override
282            public List<Team> getUserTeams(long userId, long groupId) {
283                    LinkedHashMap<String, Object> params = new LinkedHashMap<>();
284    
285                    params.put("usersTeams", userId);
286    
287                    return search(
288                            groupId, null, null, params, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
289                            null);
290            }
291    
292            @Override
293            public List<Team> search(
294                    long groupId, String name, String description,
295                    LinkedHashMap<String, Object> params, int start, int end,
296                    OrderByComparator<Team> obc) {
297    
298                    return teamFinder.findByG_N_D(
299                            groupId, name, description, params, start, end, obc);
300            }
301    
302            @Override
303            public int searchCount(
304                    long groupId, String name, String description,
305                    LinkedHashMap<String, Object> params) {
306    
307                    return teamFinder.countByG_N_D(groupId, name, description, params);
308            }
309    
310            @Override
311            public Team updateTeam(long teamId, String name, String description)
312                    throws PortalException {
313    
314                    Team team = teamPersistence.findByPrimaryKey(teamId);
315    
316                    validate(teamId, team.getGroupId(), name);
317    
318                    team.setName(name);
319                    team.setDescription(description);
320    
321                    teamPersistence.update(team);
322    
323                    return team;
324            }
325    
326            protected void validate(long teamId, long groupId, String name)
327                    throws PortalException {
328    
329                    if (Validator.isNull(name) || Validator.isNumber(name) ||
330                            (name.indexOf(CharPool.COMMA) != -1) ||
331                            (name.indexOf(CharPool.STAR) != -1)) {
332    
333                            throw new TeamNameException();
334                    }
335    
336                    Team team = teamPersistence.fetchByG_N(groupId, name);
337    
338                    if ((team != null) && (team.getTeamId() != teamId)) {
339                            throw new DuplicateTeamException("{teamId=" + teamId + "}");
340                    }
341            }
342    
343    }