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.MembershipRequestCommentsException;
018    import com.liferay.portal.kernel.exception.PortalException;
019    import com.liferay.portal.kernel.language.LanguageUtil;
020    import com.liferay.portal.kernel.util.ListUtil;
021    import com.liferay.portal.kernel.util.PropsKeys;
022    import com.liferay.portal.kernel.util.Validator;
023    import com.liferay.portal.model.Group;
024    import com.liferay.portal.model.MembershipRequest;
025    import com.liferay.portal.model.MembershipRequestConstants;
026    import com.liferay.portal.model.Resource;
027    import com.liferay.portal.model.ResourceConstants;
028    import com.liferay.portal.model.Role;
029    import com.liferay.portal.model.RoleConstants;
030    import com.liferay.portal.model.User;
031    import com.liferay.portal.model.UserGroupRole;
032    import com.liferay.portal.security.permission.ActionKeys;
033    import com.liferay.portal.security.permission.ResourceActionsUtil;
034    import com.liferay.portal.service.ServiceContext;
035    import com.liferay.portal.service.base.MembershipRequestLocalServiceBaseImpl;
036    import com.liferay.portal.util.PrefsPropsUtil;
037    import com.liferay.portal.util.ResourcePermissionUtil;
038    import com.liferay.portal.util.SubscriptionSender;
039    
040    import java.util.ArrayList;
041    import java.util.Date;
042    import java.util.LinkedHashSet;
043    import java.util.List;
044    import java.util.Set;
045    
046    /**
047     * @author Jorge Ferrer
048     */
049    public class MembershipRequestLocalServiceImpl
050            extends MembershipRequestLocalServiceBaseImpl {
051    
052            @Override
053            public MembershipRequest addMembershipRequest(
054                            long userId, long groupId, String comments,
055                            ServiceContext serviceContext)
056                    throws PortalException {
057    
058                    User user = userPersistence.findByPrimaryKey(userId);
059    
060                    validate(comments);
061    
062                    long membershipRequestId = counterLocalService.increment();
063    
064                    MembershipRequest membershipRequest =
065                            membershipRequestPersistence.create(membershipRequestId);
066    
067                    membershipRequest.setCompanyId(user.getCompanyId());
068                    membershipRequest.setUserId(userId);
069                    membershipRequest.setCreateDate(new Date());
070                    membershipRequest.setGroupId(groupId);
071                    membershipRequest.setComments(comments);
072                    membershipRequest.setStatusId(
073                            MembershipRequestConstants.STATUS_PENDING);
074    
075                    membershipRequestPersistence.update(membershipRequest);
076    
077                    notifyGroupAdministrators(membershipRequest, serviceContext);
078    
079                    return membershipRequest;
080            }
081    
082            @Override
083            public void deleteMembershipRequests(long groupId) {
084                    List<MembershipRequest> membershipRequests =
085                            membershipRequestPersistence.findByGroupId(groupId);
086    
087                    for (MembershipRequest membershipRequest : membershipRequests) {
088                            deleteMembershipRequest(membershipRequest);
089                    }
090            }
091    
092            @Override
093            public void deleteMembershipRequests(long groupId, long statusId) {
094                    List<MembershipRequest> membershipRequests =
095                            membershipRequestPersistence.findByG_S(groupId, statusId);
096    
097                    for (MembershipRequest membershipRequest : membershipRequests) {
098                            deleteMembershipRequest(membershipRequest);
099                    }
100            }
101    
102            @Override
103            public void deleteMembershipRequestsByUserId(long userId) {
104                    List<MembershipRequest> membershipRequests =
105                            membershipRequestPersistence.findByUserId(userId);
106    
107                    for (MembershipRequest membershipRequest : membershipRequests) {
108                            deleteMembershipRequest(membershipRequest);
109                    }
110            }
111    
112            @Override
113            public List<MembershipRequest> getMembershipRequests(
114                    long userId, long groupId, long statusId) {
115    
116                    return membershipRequestPersistence.findByG_U_S(
117                            groupId, userId, statusId);
118            }
119    
120            @Override
121            public boolean hasMembershipRequest(
122                    long userId, long groupId, long statusId) {
123    
124                    List<MembershipRequest> membershipRequests = getMembershipRequests(
125                            userId, groupId, statusId);
126    
127                    if (membershipRequests.isEmpty()) {
128                            return false;
129                    }
130                    else {
131                            return true;
132                    }
133            }
134    
135            @Override
136            public List<MembershipRequest> search(
137                    long groupId, int status, int start, int end) {
138    
139                    return membershipRequestPersistence.findByG_S(
140                            groupId, status, start, end);
141            }
142    
143            @Override
144            public int searchCount(long groupId, int status) {
145                    return membershipRequestPersistence.countByG_S(groupId, status);
146            }
147    
148            @Override
149            public void updateStatus(
150                            long replierUserId, long membershipRequestId, String replyComments,
151                            long statusId, boolean addUserToGroup,
152                            ServiceContext serviceContext)
153                    throws PortalException {
154    
155                    validate(replyComments);
156    
157                    MembershipRequest membershipRequest =
158                            membershipRequestPersistence.findByPrimaryKey(membershipRequestId);
159    
160                    membershipRequest.setReplyComments(replyComments);
161                    membershipRequest.setReplyDate(new Date());
162    
163                    if (replierUserId != 0) {
164                            membershipRequest.setReplierUserId(replierUserId);
165                    }
166                    else {
167                            long defaultUserId = userLocalService.getDefaultUserId(
168                                    membershipRequest.getCompanyId());
169    
170                            membershipRequest.setReplierUserId(defaultUserId);
171                    }
172    
173                    membershipRequest.setStatusId(statusId);
174    
175                    membershipRequestPersistence.update(membershipRequest);
176    
177                    if ((statusId == MembershipRequestConstants.STATUS_APPROVED) &&
178                            addUserToGroup) {
179    
180                            long[] addUserIds = new long[] {membershipRequest.getUserId()};
181    
182                            userLocalService.addGroupUsers(
183                                    membershipRequest.getGroupId(), addUserIds);
184                    }
185    
186                    if (replierUserId != 0) {
187                            notify(
188                                    membershipRequest.getUserId(), membershipRequest,
189                                    PropsKeys.SITES_EMAIL_MEMBERSHIP_REPLY_SUBJECT,
190                                    PropsKeys.SITES_EMAIL_MEMBERSHIP_REPLY_BODY, serviceContext);
191                    }
192            }
193    
194            protected List<Long> getGroupAdministratorUserIds(long groupId)
195                    throws PortalException {
196    
197                    Set<Long> userIds = new LinkedHashSet<>();
198    
199                    Group group = groupLocalService.getGroup(groupId);
200                    String modelResource = Group.class.getName();
201    
202                    List<Role> roles = ListUtil.copy(
203                            ResourceActionsUtil.getRoles(
204                                    group.getCompanyId(), group, modelResource, null));
205    
206                    List<Role> teamRoles = roleLocalService.getTeamRoles(groupId);
207    
208                    roles.addAll(teamRoles);
209    
210                    Resource resource = resourceLocalService.getResource(
211                            group.getCompanyId(), modelResource,
212                            ResourceConstants.SCOPE_INDIVIDUAL, String.valueOf(groupId));
213    
214                    List<String> actions = ResourceActionsUtil.getResourceActions(
215                            Group.class.getName());
216    
217                    for (Role role : roles) {
218                            String roleName = role.getName();
219    
220                            if (roleName.equals(RoleConstants.OWNER)) {
221                                    continue;
222                            }
223    
224                            if ((roleName.equals(RoleConstants.ORGANIZATION_ADMINISTRATOR) ||
225                                     roleName.equals(RoleConstants.ORGANIZATION_OWNER)) &&
226                                    !group.isOrganization()) {
227    
228                                    continue;
229                            }
230    
231                            if (roleName.equals(RoleConstants.SITE_ADMINISTRATOR) ||
232                                    roleName.equals(RoleConstants.SITE_OWNER) ||
233                                    roleName.equals(RoleConstants.ORGANIZATION_ADMINISTRATOR) ||
234                                    roleName.equals(RoleConstants.ORGANIZATION_OWNER)) {
235    
236                                    Role curRole = roleLocalService.getRole(
237                                            group.getCompanyId(), roleName);
238    
239                                    List<UserGroupRole> userGroupRoles =
240                                            userGroupRoleLocalService.getUserGroupRolesByGroupAndRole(
241                                                    groupId, curRole.getRoleId());
242    
243                                    for (UserGroupRole userGroupRole : userGroupRoles) {
244                                            userIds.add(userGroupRole.getUserId());
245                                    }
246                            }
247    
248                            List<String> currentIndividualActions = new ArrayList<>();
249                            List<String> currentGroupActions = new ArrayList<>();
250                            List<String> currentGroupTemplateActions = new ArrayList<>();
251                            List<String> currentCompanyActions = new ArrayList<>();
252    
253                            ResourcePermissionUtil.populateResourcePermissionActionIds(
254                                    groupId, role, resource, actions, currentIndividualActions,
255                                    currentGroupActions, currentGroupTemplateActions,
256                                    currentCompanyActions);
257    
258                            if (currentIndividualActions.contains(ActionKeys.ASSIGN_MEMBERS) ||
259                                    currentGroupActions.contains(ActionKeys.ASSIGN_MEMBERS) ||
260                                    currentGroupTemplateActions.contains(
261                                            ActionKeys.ASSIGN_MEMBERS) ||
262                                    currentCompanyActions.contains(ActionKeys.ASSIGN_MEMBERS)) {
263    
264                                    List<UserGroupRole> currentUserGroupRoles =
265                                            userGroupRoleLocalService.getUserGroupRolesByGroupAndRole(
266                                                    groupId, role.getRoleId());
267    
268                                    for (UserGroupRole userGroupRole : currentUserGroupRoles) {
269                                            userIds.add(userGroupRole.getUserId());
270                                    }
271                            }
272                    }
273    
274                    return new ArrayList<>(userIds);
275            }
276    
277            protected void notify(
278                            long userId, MembershipRequest membershipRequest,
279                            String subjectProperty, String bodyProperty,
280                            ServiceContext serviceContext)
281                    throws PortalException {
282    
283                    User user = userPersistence.findByPrimaryKey(userId);
284                    User requestUser = userPersistence.findByPrimaryKey(
285                            membershipRequest.getUserId());
286    
287                    String fromName = PrefsPropsUtil.getStringFromNames(
288                            membershipRequest.getCompanyId(), PropsKeys.SITES_EMAIL_FROM_NAME,
289                            PropsKeys.ADMIN_EMAIL_FROM_NAME);
290    
291                    String fromAddress = PrefsPropsUtil.getStringFromNames(
292                            membershipRequest.getCompanyId(),
293                            PropsKeys.SITES_EMAIL_FROM_ADDRESS,
294                            PropsKeys.ADMIN_EMAIL_FROM_ADDRESS);
295    
296                    String toName = user.getFullName();
297                    String toAddress = user.getEmailAddress();
298    
299                    String subject = PrefsPropsUtil.getContent(
300                            membershipRequest.getCompanyId(), subjectProperty);
301    
302                    String body = PrefsPropsUtil.getContent(
303                            membershipRequest.getCompanyId(), bodyProperty);
304    
305                    String statusKey = null;
306    
307                    if (membershipRequest.getStatusId() ==
308                                    MembershipRequestConstants.STATUS_APPROVED) {
309    
310                            statusKey = "approved";
311                    }
312                    else if (membershipRequest.getStatusId() ==
313                                            MembershipRequestConstants.STATUS_DENIED) {
314    
315                            statusKey = "denied";
316                    }
317                    else {
318                            statusKey = "pending";
319                    }
320    
321                    SubscriptionSender subscriptionSender = new SubscriptionSender();
322    
323                    subscriptionSender.setBody(body);
324                    subscriptionSender.setCompanyId(membershipRequest.getCompanyId());
325                    subscriptionSender.setContextAttributes(
326                            "[$COMMENTS$]", membershipRequest.getComments(),
327                            "[$REPLY_COMMENTS$]", membershipRequest.getReplyComments(),
328                            "[$REQUEST_USER_ADDRESS$]", requestUser.getEmailAddress(),
329                            "[$REQUEST_USER_NAME$]", requestUser.getFullName(), "[$STATUS$]",
330                            LanguageUtil.get(user.getLocale(), statusKey), "[$USER_ADDRESS$]",
331                            user.getEmailAddress(), "[$USER_NAME$]", user.getFullName());
332                    subscriptionSender.setFrom(fromAddress, fromName);
333                    subscriptionSender.setHtmlFormat(true);
334                    subscriptionSender.setMailId(
335                            "membership_request", membershipRequest.getMembershipRequestId());
336                    subscriptionSender.setScopeGroupId(membershipRequest.getGroupId());
337                    subscriptionSender.setServiceContext(serviceContext);
338                    subscriptionSender.setSubject(subject);
339    
340                    subscriptionSender.addRuntimeSubscribers(toAddress, toName);
341    
342                    subscriptionSender.flushNotificationsAsync();
343            }
344    
345            protected void notifyGroupAdministrators(
346                            MembershipRequest membershipRequest, ServiceContext serviceContext)
347                    throws PortalException {
348    
349                    List<Long> userIds = getGroupAdministratorUserIds(
350                            membershipRequest.getGroupId());
351    
352                    for (Long userId : userIds) {
353                            notify(
354                                    userId, membershipRequest,
355                                    PropsKeys.SITES_EMAIL_MEMBERSHIP_REQUEST_SUBJECT,
356                                    PropsKeys.SITES_EMAIL_MEMBERSHIP_REQUEST_BODY, serviceContext);
357                    }
358            }
359    
360            protected void validate(String comments) throws PortalException {
361                    if (Validator.isNull(comments) || Validator.isNumber(comments)) {
362                            throw new MembershipRequestCommentsException();
363                    }
364            }
365    
366    }