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