1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portal.service.impl;
24  
25  import com.liferay.portal.PortalException;
26  import com.liferay.portal.RequiredUserException;
27  import com.liferay.portal.ReservedUserEmailAddressException;
28  import com.liferay.portal.SystemException;
29  import com.liferay.portal.kernel.util.ArrayUtil;
30  import com.liferay.portal.model.Address;
31  import com.liferay.portal.model.Company;
32  import com.liferay.portal.model.Contact;
33  import com.liferay.portal.model.EmailAddress;
34  import com.liferay.portal.model.Group;
35  import com.liferay.portal.model.GroupConstants;
36  import com.liferay.portal.model.Organization;
37  import com.liferay.portal.model.Phone;
38  import com.liferay.portal.model.Role;
39  import com.liferay.portal.model.User;
40  import com.liferay.portal.model.UserGroupRole;
41  import com.liferay.portal.model.Website;
42  import com.liferay.portal.security.auth.PrincipalException;
43  import com.liferay.portal.security.permission.ActionKeys;
44  import com.liferay.portal.security.permission.PermissionChecker;
45  import com.liferay.portal.service.ServiceContext;
46  import com.liferay.portal.service.base.UserServiceBaseImpl;
47  import com.liferay.portal.service.permission.GroupPermissionUtil;
48  import com.liferay.portal.service.permission.OrganizationPermissionUtil;
49  import com.liferay.portal.service.permission.PasswordPolicyPermissionUtil;
50  import com.liferay.portal.service.permission.RolePermissionUtil;
51  import com.liferay.portal.service.permission.UserGroupPermissionUtil;
52  import com.liferay.portal.service.permission.UserPermissionUtil;
53  import com.liferay.portal.util.PropsValues;
54  import com.liferay.portlet.announcements.model.AnnouncementsDelivery;
55  import com.liferay.portlet.enterpriseadmin.util.EnterpriseAdminUtil;
56  
57  import java.util.List;
58  import java.util.Locale;
59  
60  /**
61   * <a href="UserServiceImpl.java.html"><b><i>View Source</i></b></a>
62   *
63   * @author Brian Wing Shun Chan
64   * @author Brian Myunghun Kim
65   * @author Scott Lee
66   * @author Jorge Ferrer
67   * @author Julio Camarero
68   *
69   */
70  public class UserServiceImpl extends UserServiceBaseImpl {
71  
72      public void addGroupUsers(long groupId, long[] userIds)
73          throws PortalException, SystemException {
74  
75          try {
76              GroupPermissionUtil.check(
77                  getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
78          }
79          catch (PrincipalException pe) {
80  
81              // Allow any user to join open communities
82  
83              boolean hasPermission = false;
84  
85              if (userIds.length == 0) {
86                  hasPermission = true;
87              }
88              else if (userIds.length == 1) {
89                  User user = getUser();
90  
91                  if (user.getUserId() == userIds[0]) {
92                      Group group = groupPersistence.findByPrimaryKey(groupId);
93  
94                      if (user.getCompanyId() == group.getCompanyId()) {
95                          int type = group.getType();
96  
97                          if (type == GroupConstants.TYPE_COMMUNITY_OPEN) {
98                              hasPermission = true;
99                          }
100                     }
101                 }
102             }
103 
104             if (!hasPermission) {
105                 throw new PrincipalException();
106             }
107         }
108 
109         userLocalService.addGroupUsers(groupId, userIds);
110     }
111 
112     public void addOrganizationUsers(long organizationId, long[] userIds)
113         throws PortalException, SystemException {
114 
115         OrganizationPermissionUtil.check(
116             getPermissionChecker(), organizationId, ActionKeys.ASSIGN_MEMBERS);
117 
118         validateOrganizationUsers(userIds);
119 
120         userLocalService.addOrganizationUsers(organizationId, userIds);
121     }
122 
123     public void addPasswordPolicyUsers(long passwordPolicyId, long[] userIds)
124         throws PortalException, SystemException {
125 
126         PasswordPolicyPermissionUtil.check(
127             getPermissionChecker(), passwordPolicyId,
128             ActionKeys.ASSIGN_MEMBERS);
129 
130         userLocalService.addPasswordPolicyUsers(passwordPolicyId, userIds);
131     }
132 
133     public void addRoleUsers(long roleId, long[] userIds)
134         throws PortalException, SystemException {
135 
136         RolePermissionUtil.check(
137             getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
138 
139         userLocalService.addRoleUsers(roleId, userIds);
140     }
141 
142     public void addUserGroupUsers(long userGroupId, long[] userIds)
143         throws PortalException, SystemException {
144 
145         UserGroupPermissionUtil.check(
146             getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
147 
148         userLocalService.addUserGroupUsers(userGroupId, userIds);
149     }
150 
151     public User addUser(
152             long companyId, boolean autoPassword, String password1,
153             String password2, boolean autoScreenName, String screenName,
154             String emailAddress, String openId, Locale locale, String firstName,
155             String middleName, String lastName, int prefixId, int suffixId,
156             boolean male, int birthdayMonth, int birthdayDay, int birthdayYear,
157             String jobTitle, long[] groupIds, long[] organizationIds,
158             long[] roleIds, long[] userGroupIds, boolean sendEmail,
159             ServiceContext serviceContext)
160         throws PortalException, SystemException {
161 
162         Company company = companyPersistence.findByPrimaryKey(companyId);
163 
164         long creatorUserId = 0;
165 
166         try {
167             creatorUserId = getUserId();
168         }
169         catch (PrincipalException pe) {
170         }
171 
172         if ((creatorUserId != 0) || !company.isStrangers()) {
173             UserPermissionUtil.check(
174                 getPermissionChecker(), 0, organizationIds,
175                 ActionKeys.ADD_USER);
176         }
177 
178         if (creatorUserId == 0) {
179             if (!company.isStrangersWithMx() &&
180                 company.hasCompanyMx(emailAddress)) {
181 
182                 throw new ReservedUserEmailAddressException();
183             }
184         }
185 
186         return userLocalService.addUser(
187             creatorUserId, companyId, autoPassword, password1, password2,
188             autoScreenName, screenName, emailAddress, openId, locale, firstName,
189             middleName, lastName, prefixId, suffixId, male, birthdayMonth,
190             birthdayDay, birthdayYear, jobTitle, groupIds, organizationIds,
191             roleIds, userGroupIds, sendEmail, serviceContext);
192     }
193 
194     public User addUser(
195             long companyId, boolean autoPassword, String password1,
196             String password2, boolean autoScreenName, String screenName,
197             String emailAddress, String openId, Locale locale, String firstName,
198             String middleName, String lastName, int prefixId, int suffixId,
199             boolean male, int birthdayMonth, int birthdayDay, int birthdayYear,
200             String jobTitle, long[] groupIds, long[] organizationIds,
201             long[] roleIds, long[] userGroupIds, boolean sendEmail,
202             List<Address> addresses, List<EmailAddress> emailAddresses,
203             List<Phone> phones, List<Website> websites,
204             List<AnnouncementsDelivery> announcementsDelivers,
205             ServiceContext serviceContext)
206         throws PortalException, SystemException {
207 
208         User user = addUser(
209             companyId, autoPassword, password1, password2, autoScreenName,
210             screenName, emailAddress, openId, locale, firstName, middleName,
211             lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay,
212             birthdayYear, jobTitle, groupIds, organizationIds, roleIds,
213             userGroupIds, sendEmail, serviceContext);
214 
215         EnterpriseAdminUtil.updateAddresses(
216             Contact.class.getName(), user.getContactId(), addresses);
217 
218         EnterpriseAdminUtil.updateEmailAddresses(
219             Contact.class.getName(), user.getContactId(), emailAddresses);
220 
221         EnterpriseAdminUtil.updatePhones(
222             Contact.class.getName(), user.getContactId(), phones);
223 
224         EnterpriseAdminUtil.updateWebsites(
225             Contact.class.getName(), user.getContactId(), websites);
226 
227         updateAnnouncementsDeliveries(user.getUserId(), announcementsDelivers);
228 
229         return user;
230     }
231 
232     public void deletePortrait(long userId)
233         throws PortalException, SystemException {
234 
235         UserPermissionUtil.check(
236             getPermissionChecker(), userId, ActionKeys.UPDATE);
237 
238         userLocalService.deletePortrait(userId);
239     }
240 
241     public void deleteRoleUser(long roleId, long userId)
242         throws PortalException, SystemException {
243 
244         RolePermissionUtil.check(
245             getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
246 
247         userLocalService.deleteRoleUser(roleId, userId);
248     }
249 
250     public void deleteUser(long userId)
251         throws PortalException, SystemException {
252 
253         if (getUserId() == userId) {
254             throw new RequiredUserException();
255         }
256 
257         UserPermissionUtil.check(
258             getPermissionChecker(), userId, ActionKeys.DELETE);
259 
260         userLocalService.deleteUser(userId);
261     }
262 
263     public long getDefaultUserId(long companyId)
264         throws PortalException, SystemException {
265 
266         return userLocalService.getDefaultUserId(companyId);
267     }
268 
269     public long[] getGroupUserIds(long groupId) throws SystemException {
270         return userLocalService.getGroupUserIds(groupId);
271     }
272 
273     public long[] getOrganizationUserIds(long organizationId)
274         throws SystemException {
275 
276         return userLocalService.getOrganizationUserIds(organizationId);
277     }
278 
279     public long[] getRoleUserIds(long roleId) throws SystemException {
280         return userLocalService.getRoleUserIds(roleId);
281     }
282 
283     public User getUserByEmailAddress(long companyId, String emailAddress)
284         throws PortalException, SystemException {
285 
286         User user = userLocalService.getUserByEmailAddress(
287             companyId, emailAddress);
288 
289         UserPermissionUtil.check(
290             getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
291 
292         return user;
293     }
294 
295     public User getUserById(long userId)
296         throws PortalException, SystemException {
297 
298         User user = userLocalService.getUserById(userId);
299 
300         UserPermissionUtil.check(
301             getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
302 
303         return user;
304     }
305 
306     public User getUserByScreenName(long companyId, String screenName)
307         throws PortalException, SystemException {
308 
309         User user = userLocalService.getUserByScreenName(
310             companyId, screenName);
311 
312         UserPermissionUtil.check(
313             getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
314 
315         return user;
316     }
317 
318     public long getUserIdByEmailAddress(long companyId, String emailAddress)
319         throws PortalException, SystemException {
320 
321         User user = getUserByEmailAddress(companyId, emailAddress);
322 
323         return user.getUserId();
324     }
325 
326     public long getUserIdByScreenName(long companyId, String screenName)
327         throws PortalException, SystemException {
328 
329         User user = getUserByScreenName(companyId, screenName);
330 
331         return user.getUserId();
332     }
333 
334     public boolean hasGroupUser(long groupId, long userId)
335         throws SystemException {
336 
337         return userLocalService.hasGroupUser(groupId, userId);
338     }
339 
340     public boolean hasRoleUser(long roleId, long userId)
341         throws SystemException {
342 
343         return userLocalService.hasRoleUser(roleId, userId);
344     }
345 
346     public void setRoleUsers(long roleId, long[] userIds)
347         throws PortalException, SystemException {
348 
349         RolePermissionUtil.check(
350             getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
351 
352         userLocalService.setRoleUsers(roleId, userIds);
353     }
354 
355     public void setUserGroupUsers(long userGroupId, long[] userIds)
356         throws PortalException, SystemException {
357 
358         UserGroupPermissionUtil.check(
359             getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
360 
361         userLocalService.setUserGroupUsers(userGroupId, userIds);
362     }
363 
364     public void unsetGroupUsers(long groupId, long[] userIds)
365         throws PortalException, SystemException {
366 
367         try {
368             GroupPermissionUtil.check(
369                 getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
370         }
371         catch (PrincipalException pe) {
372 
373             // Allow any user to leave open and restricted communities
374 
375             boolean hasPermission = false;
376 
377             if (userIds.length == 0) {
378                 hasPermission = true;
379             }
380             else if (userIds.length == 1) {
381                 User user = getUser();
382 
383                 if (user.getUserId() == userIds[0]) {
384                     Group group = groupPersistence.findByPrimaryKey(groupId);
385 
386                     if (user.getCompanyId() == group.getCompanyId()) {
387                         int type = group.getType();
388 
389                         if ((type == GroupConstants.TYPE_COMMUNITY_OPEN) ||
390                             (type ==
391                                 GroupConstants.TYPE_COMMUNITY_RESTRICTED)) {
392 
393                             hasPermission = true;
394                         }
395                     }
396                 }
397             }
398 
399             if (!hasPermission) {
400                 throw new PrincipalException();
401             }
402         }
403 
404         userLocalService.unsetGroupUsers(groupId, userIds);
405     }
406 
407     public void unsetOrganizationUsers(long organizationId, long[] userIds)
408         throws PortalException, SystemException {
409 
410         OrganizationPermissionUtil.check(
411             getPermissionChecker(), organizationId, ActionKeys.ASSIGN_MEMBERS);
412 
413         userLocalService.unsetOrganizationUsers(organizationId, userIds);
414     }
415 
416     public void unsetPasswordPolicyUsers(long passwordPolicyId, long[] userIds)
417         throws PortalException, SystemException {
418 
419         PasswordPolicyPermissionUtil.check(
420             getPermissionChecker(), passwordPolicyId,
421             ActionKeys.ASSIGN_MEMBERS);
422 
423         userLocalService.unsetPasswordPolicyUsers(passwordPolicyId, userIds);
424     }
425 
426     public void unsetRoleUsers(long roleId, long[] userIds)
427         throws PortalException, SystemException {
428 
429         RolePermissionUtil.check(
430             getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
431 
432         userLocalService.unsetRoleUsers(roleId, userIds);
433     }
434 
435     public void unsetUserGroupUsers(long userGroupId, long[] userIds)
436         throws PortalException, SystemException {
437 
438         UserGroupPermissionUtil.check(
439             getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
440 
441         userLocalService.unsetUserGroupUsers(userGroupId, userIds);
442     }
443 
444     public User updateActive(long userId, boolean active)
445         throws PortalException, SystemException {
446 
447         if ((getUserId() == userId) && !active) {
448             throw new RequiredUserException();
449         }
450 
451         UserPermissionUtil.check(
452             getPermissionChecker(), userId, ActionKeys.DELETE);
453 
454         return userLocalService.updateActive(userId, active);
455     }
456 
457     public User updateAgreedToTermsOfUse(
458             long userId, boolean agreedToTermsOfUse)
459         throws PortalException, SystemException {
460 
461         UserPermissionUtil.check(
462             getPermissionChecker(), userId, ActionKeys.UPDATE);
463 
464         return userLocalService.updateAgreedToTermsOfUse(
465             userId, agreedToTermsOfUse);
466     }
467 
468     public void updateEmailAddress(
469             long userId, String password, String emailAddress1,
470             String emailAddress2)
471         throws PortalException, SystemException {
472 
473         UserPermissionUtil.check(
474             getPermissionChecker(), userId, ActionKeys.UPDATE);
475 
476         userLocalService.updateEmailAddress(
477             userId, password, emailAddress1, emailAddress2);
478     }
479 
480     public User updateLockout(long userId, boolean lockout)
481         throws PortalException, SystemException {
482 
483         UserPermissionUtil.check(
484             getPermissionChecker(), userId, ActionKeys.DELETE);
485 
486         return userLocalService.updateLockoutById(userId, lockout);
487     }
488 
489     public void updateOpenId(long userId, String openId)
490         throws PortalException, SystemException {
491 
492         UserPermissionUtil.check(
493             getPermissionChecker(), userId, ActionKeys.UPDATE);
494 
495         userLocalService.updateOpenId(userId, openId);
496     }
497 
498     public void updateOrganizations(long userId, long[] organizationIds)
499         throws PortalException, SystemException {
500 
501         UserPermissionUtil.check(
502             getPermissionChecker(), userId, ActionKeys.UPDATE);
503 
504         userLocalService.updateOrganizations(userId, organizationIds);
505     }
506 
507     public User updatePassword(
508             long userId, String password1, String password2,
509             boolean passwordReset)
510         throws PortalException, SystemException {
511 
512         UserPermissionUtil.check(
513             getPermissionChecker(), userId, ActionKeys.UPDATE);
514 
515         return userLocalService.updatePassword(
516             userId, password1, password2, passwordReset);
517     }
518 
519     public void updatePortrait(long userId, byte[] bytes)
520         throws PortalException, SystemException {
521 
522         UserPermissionUtil.check(
523             getPermissionChecker(), userId, ActionKeys.UPDATE);
524 
525         userLocalService.updatePortrait(userId, bytes);
526     }
527 
528     public void updateReminderQuery(
529             long userId, String question, String answer)
530         throws PortalException, SystemException {
531 
532         UserPermissionUtil.check(
533             getPermissionChecker(), userId, ActionKeys.UPDATE);
534 
535         userLocalService.updateReminderQuery(userId, question, answer);
536     }
537 
538     public void updateScreenName(long userId, String screenName)
539         throws PortalException, SystemException {
540 
541         UserPermissionUtil.check(
542             getPermissionChecker(), userId, ActionKeys.UPDATE);
543 
544         userLocalService.updateScreenName(userId, screenName);
545     }
546 
547     public User updateUser(
548             long userId, String oldPassword, String newPassword1,
549             String newPassword2, boolean passwordReset,
550             String reminderQueryQuestion, String reminderQueryAnswer,
551             String screenName, String emailAddress, String openId,
552             String languageId, String timeZoneId, String greeting,
553             String comments, String firstName, String middleName,
554             String lastName, int prefixId, int suffixId, boolean male,
555             int birthdayMonth, int birthdayDay, int birthdayYear, String smsSn,
556             String aimSn, String facebookSn, String icqSn, String jabberSn,
557             String msnSn, String mySpaceSn, String skypeSn, String twitterSn,
558             String ymSn, String jobTitle, long[] groupIds,
559             long[] organizationIds, long[] roleIds,
560             List<UserGroupRole> userGroupRoles, long[] userGroupIds,
561             ServiceContext serviceContext)
562         throws PortalException, SystemException {
563 
564         UserPermissionUtil.check(
565             getPermissionChecker(), userId, organizationIds, ActionKeys.UPDATE);
566 
567         long curUserId = getUserId();
568 
569         if (curUserId == userId) {
570             emailAddress = emailAddress.trim().toLowerCase();
571 
572             User user = userPersistence.findByPrimaryKey(userId);
573 
574             if (!emailAddress.equalsIgnoreCase(user.getEmailAddress())) {
575                 if (!user.hasCompanyMx() && user.hasCompanyMx(emailAddress)) {
576                     Company company = companyPersistence.findByPrimaryKey(
577                         user.getCompanyId());
578 
579                     if (!company.isStrangersWithMx()) {
580                         throw new ReservedUserEmailAddressException();
581                     }
582                 }
583             }
584         }
585 
586         if (groupIds != null) {
587             groupIds = checkGroups(userId, groupIds);
588         }
589 
590         if (organizationIds != null) {
591             organizationIds = checkOrganizations(userId, organizationIds);
592         }
593 
594         if (roleIds != null) {
595             roleIds = checkRoles(userId, roleIds);
596         }
597 
598         if (userGroupRoles != null) {
599             userGroupRoles = checkUserGroupRoles(userId, userGroupRoles);
600         }
601 
602         return userLocalService.updateUser(
603             userId, oldPassword, newPassword1, newPassword2, passwordReset,
604             reminderQueryQuestion, reminderQueryAnswer, screenName,
605             emailAddress, openId, languageId, timeZoneId, greeting, comments,
606             firstName, middleName, lastName, prefixId, suffixId, male,
607             birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn, facebookSn,
608             icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn, ymSn,
609             jobTitle, groupIds, organizationIds, roleIds, userGroupRoles,
610             userGroupIds, serviceContext);
611     }
612 
613     public User updateUser(
614             long userId, String oldPassword, String newPassword1,
615             String newPassword2, boolean passwordReset,
616             String reminderQueryQuestion, String reminderQueryAnswer,
617             String screenName, String emailAddress, String openId,
618             String languageId, String timeZoneId, String greeting,
619             String comments, String firstName, String middleName,
620             String lastName, int prefixId, int suffixId, boolean male,
621             int birthdayMonth, int birthdayDay, int birthdayYear, String smsSn,
622             String aimSn, String facebookSn, String icqSn, String jabberSn,
623             String msnSn, String mySpaceSn, String skypeSn, String twitterSn,
624             String ymSn, String jobTitle, long[] groupIds,
625             long[] organizationIds, long[] roleIds,
626             List<UserGroupRole> userGroupRoles, long[] userGroupIds,
627             List<Address> addresses, List<EmailAddress> emailAddresses,
628             List<Phone> phones, List<Website> websites,
629             List<AnnouncementsDelivery> announcementsDelivers,
630             ServiceContext serviceContext)
631         throws PortalException, SystemException {
632 
633         User user = updateUser(
634             userId, oldPassword, newPassword1, newPassword2, passwordReset,
635             reminderQueryQuestion, reminderQueryAnswer, screenName,
636             emailAddress, openId, languageId, timeZoneId, greeting, comments,
637             firstName, middleName, lastName, prefixId, suffixId, male,
638             birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn, facebookSn,
639             icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn, ymSn,
640             jobTitle, groupIds, organizationIds, roleIds,
641             userGroupRoles, userGroupIds, serviceContext);
642 
643         EnterpriseAdminUtil.updateAddresses(
644             Contact.class.getName(), user.getContactId(), addresses);
645 
646         EnterpriseAdminUtil.updateEmailAddresses(
647             Contact.class.getName(), user.getContactId(), emailAddresses);
648 
649         EnterpriseAdminUtil.updatePhones(
650             Contact.class.getName(), user.getContactId(), phones);
651 
652         EnterpriseAdminUtil.updateWebsites(
653             Contact.class.getName(), user.getContactId(), websites);
654 
655         updateAnnouncementsDeliveries(user.getUserId(), announcementsDelivers);
656 
657         return user;
658     }
659 
660     protected long[] checkGroups(long userId, long[] groupIds)
661         throws PortalException, SystemException {
662 
663         // Add back any groups that the administrator does not have the rights
664         // to remove and check that he has the permission to add any new group
665 
666         List<Group> oldGroups = groupLocalService.getUserGroups(userId);
667         long[] oldGroupIds = new long[oldGroups.size()];
668 
669         for (int i = 0; i < oldGroups.size(); i++) {
670             Group group = oldGroups.get(i);
671 
672             if (!ArrayUtil.contains(groupIds, group.getGroupId()) &&
673                 !GroupPermissionUtil.contains(
674                     getPermissionChecker(), group.getGroupId(),
675                     ActionKeys.ASSIGN_MEMBERS)) {
676 
677                 groupIds = ArrayUtil.append(groupIds, group.getGroupId());
678             }
679 
680             oldGroupIds[i] = group.getGroupId();
681         }
682 
683         for (long groupId : groupIds) {
684             if (!ArrayUtil.contains(oldGroupIds, groupId)) {
685                 GroupPermissionUtil.check(
686                     getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
687             }
688         }
689 
690         return groupIds;
691     }
692 
693     protected long[] checkOrganizations(long userId, long[] organizationIds)
694         throws PortalException, SystemException {
695 
696         // Add back any organizations that the administrator does not have the
697         // rights to remove and check that he has the permission to add any new
698         // organization
699 
700         List<Organization> oldOrganizations =
701             organizationLocalService.getUserOrganizations(userId);
702         long[] oldOrganizationIds = new long[oldOrganizations.size()];
703 
704         for (int i = 0; i < oldOrganizations.size(); i++) {
705             Organization organization = oldOrganizations.get(i);
706 
707             if (!ArrayUtil.contains(
708                     organizationIds, organization.getOrganizationId()) &&
709                 !OrganizationPermissionUtil.contains(
710                     getPermissionChecker(), organization.getOrganizationId(),
711                     ActionKeys.ASSIGN_MEMBERS)) {
712 
713                 organizationIds = ArrayUtil.append(
714                     organizationIds, organization.getOrganizationId());
715             }
716 
717             oldOrganizationIds[i] = organization.getOrganizationId();
718         }
719 
720         for (long organizationId : organizationIds) {
721             if (!ArrayUtil.contains(oldOrganizationIds, organizationId)) {
722                 OrganizationPermissionUtil.check(
723                     getPermissionChecker(), organizationId,
724                     ActionKeys.ASSIGN_MEMBERS);
725             }
726         }
727 
728         return organizationIds;
729     }
730 
731     protected long[] checkRoles(long userId, long[] roleIds)
732         throws PrincipalException, SystemException {
733 
734         // Add back any roles that the administrator does not have the rights to
735         // remove and check that he has the permission to add any new role
736 
737         List<Role> oldRoles = roleLocalService.getUserRoles(userId);
738         long[] oldRoleIds = new long[oldRoles.size()];
739 
740         for (int i = 0; i < oldRoles.size(); i++) {
741             Role role = oldRoles.get(i);
742 
743             if (!ArrayUtil.contains(roleIds, role.getRoleId()) &&
744                 !RolePermissionUtil.contains(
745                     getPermissionChecker(), role.getRoleId(),
746                     ActionKeys.ASSIGN_MEMBERS)) {
747 
748                 roleIds = ArrayUtil.append(roleIds, role.getRoleId());
749             }
750 
751             oldRoleIds[i] = role.getRoleId();
752         }
753 
754         for (long roleId : roleIds) {
755             if (!ArrayUtil.contains(oldRoleIds, roleId)) {
756                 RolePermissionUtil.check(
757                     getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
758             }
759         }
760 
761         return roleIds;
762     }
763 
764     protected List<UserGroupRole> checkUserGroupRoles(
765             long userId, List<UserGroupRole> userGroupRoles)
766         throws PortalException, SystemException {
767 
768         // Add back any group roles that the administrator does not have the
769         // rights to remove
770 
771         List<UserGroupRole> oldUserGroupRoles =
772             userGroupRoleLocalService.getUserGroupRoles(userId);
773 
774         for (UserGroupRole oldUserGroupRole : oldUserGroupRoles) {
775             if (!userGroupRoles.contains(oldUserGroupRole) &&
776                 (!GroupPermissionUtil.contains(
777                     getPermissionChecker(), oldUserGroupRole.getGroupId(),
778                     ActionKeys.ASSIGN_MEMBERS) ||
779                 !RolePermissionUtil.contains(
780                     getPermissionChecker(), oldUserGroupRole.getRoleId(),
781                     ActionKeys.ASSIGN_MEMBERS))) {
782 
783                 userGroupRoles.add(oldUserGroupRole);
784             }
785         }
786 
787         for (UserGroupRole userGroupRole : userGroupRoles) {
788             if (!oldUserGroupRoles.contains(userGroupRole)) {
789 
790                 if (!GroupPermissionUtil.contains(
791                         getPermissionChecker(), userGroupRole.getGroupId(),
792                         ActionKeys.ASSIGN_MEMBERS) ||
793                     !RolePermissionUtil.contains(
794                         getPermissionChecker(), userGroupRole.getRoleId(),
795                         ActionKeys.ASSIGN_MEMBERS)) {
796 
797                     throw new PrincipalException();
798                 }
799             }
800         }
801 
802         return userGroupRoles;
803     }
804 
805     protected void updateAnnouncementsDeliveries(
806             long userId, List<AnnouncementsDelivery> announcementsDeliveries)
807         throws PortalException, SystemException {
808 
809         for (AnnouncementsDelivery announcementsDelivery :
810                 announcementsDeliveries) {
811 
812             announcementsDeliveryService.updateDelivery(
813                 userId, announcementsDelivery.getType(),
814                 announcementsDelivery.getEmail(),
815                 announcementsDelivery.getSms(),
816                 announcementsDelivery.getWebsite());
817         }
818     }
819 
820     protected void validateOrganizationUsers(long[] userIds)
821         throws PortalException, SystemException {
822 
823         PermissionChecker permissionChecker = getPermissionChecker();
824 
825         if (!PropsValues.ORGANIZATIONS_ASSIGNMENT_STRICT ||
826             permissionChecker.isCompanyAdmin()) {
827 
828             return;
829         }
830 
831         List<Organization> organizations =
832             organizationService.getManageableOrganizations(
833                 getUserId(), ActionKeys.MANAGE_USERS);
834 
835         for (long userId : userIds) {
836             boolean allowed = false;
837 
838             for (Organization organization : organizations) {
839                 if (userLocalService.hasOrganizationUser(
840                         organization.getOrganizationId(), userId)) {
841 
842                     allowed = true;
843 
844                     break;
845                 }
846             }
847 
848             if (!allowed) {
849                 throw new PrincipalException();
850             }
851         }
852     }
853 
854 }