1
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
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
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
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
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
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
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
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 }