001
014
015 package com.liferay.portal.service.impl;
016
017 import com.liferay.portal.RequiredUserException;
018 import com.liferay.portal.ReservedUserEmailAddressException;
019 import com.liferay.portal.UserEmailAddressException;
020 import com.liferay.portal.UserScreenNameException;
021 import com.liferay.portal.kernel.exception.PortalException;
022 import com.liferay.portal.kernel.exception.SystemException;
023 import com.liferay.portal.kernel.util.ArrayUtil;
024 import com.liferay.portal.model.Address;
025 import com.liferay.portal.model.Company;
026 import com.liferay.portal.model.Contact;
027 import com.liferay.portal.model.EmailAddress;
028 import com.liferay.portal.model.Group;
029 import com.liferay.portal.model.GroupConstants;
030 import com.liferay.portal.model.Organization;
031 import com.liferay.portal.model.Phone;
032 import com.liferay.portal.model.Role;
033 import com.liferay.portal.model.User;
034 import com.liferay.portal.model.UserGroupRole;
035 import com.liferay.portal.model.Website;
036 import com.liferay.portal.security.auth.PrincipalException;
037 import com.liferay.portal.security.permission.ActionKeys;
038 import com.liferay.portal.security.permission.PermissionChecker;
039 import com.liferay.portal.service.ServiceContext;
040 import com.liferay.portal.service.base.UserServiceBaseImpl;
041 import com.liferay.portal.service.permission.GroupPermissionUtil;
042 import com.liferay.portal.service.permission.OrganizationPermissionUtil;
043 import com.liferay.portal.service.permission.PasswordPolicyPermissionUtil;
044 import com.liferay.portal.service.permission.PortalPermissionUtil;
045 import com.liferay.portal.service.permission.RolePermissionUtil;
046 import com.liferay.portal.service.permission.TeamPermissionUtil;
047 import com.liferay.portal.service.permission.UserGroupPermissionUtil;
048 import com.liferay.portal.service.permission.UserPermissionUtil;
049 import com.liferay.portal.util.PropsValues;
050 import com.liferay.portlet.announcements.model.AnnouncementsDelivery;
051 import com.liferay.portlet.enterpriseadmin.util.EnterpriseAdminUtil;
052
053 import java.util.List;
054 import java.util.Locale;
055
056
063 public class UserServiceImpl extends UserServiceBaseImpl {
064
065 public void addGroupUsers(long groupId, long[] userIds)
066 throws PortalException, SystemException {
067
068 try {
069 GroupPermissionUtil.check(
070 getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
071 }
072 catch (PrincipalException pe) {
073
074
075
076 boolean hasPermission = false;
077
078 if (userIds.length == 0) {
079 hasPermission = true;
080 }
081 else if (userIds.length == 1) {
082 User user = getUser();
083
084 if (user.getUserId() == userIds[0]) {
085 Group group = groupPersistence.findByPrimaryKey(groupId);
086
087 if (user.getCompanyId() == group.getCompanyId()) {
088 int type = group.getType();
089
090 if (type == GroupConstants.TYPE_COMMUNITY_OPEN) {
091 hasPermission = true;
092 }
093 }
094 }
095 }
096
097 if (!hasPermission) {
098 throw new PrincipalException();
099 }
100 }
101
102 userLocalService.addGroupUsers(groupId, userIds);
103 }
104
105 public void addOrganizationUsers(long organizationId, long[] userIds)
106 throws PortalException, SystemException {
107
108 OrganizationPermissionUtil.check(
109 getPermissionChecker(), organizationId, ActionKeys.ASSIGN_MEMBERS);
110
111 validateOrganizationUsers(userIds);
112
113 userLocalService.addOrganizationUsers(organizationId, userIds);
114 }
115
116 public void addPasswordPolicyUsers(long passwordPolicyId, long[] userIds)
117 throws PortalException, SystemException {
118
119 PasswordPolicyPermissionUtil.check(
120 getPermissionChecker(), passwordPolicyId,
121 ActionKeys.ASSIGN_MEMBERS);
122
123 userLocalService.addPasswordPolicyUsers(passwordPolicyId, userIds);
124 }
125
126 public void addRoleUsers(long roleId, long[] userIds)
127 throws PortalException, SystemException {
128
129 RolePermissionUtil.check(
130 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
131
132 userLocalService.addRoleUsers(roleId, userIds);
133 }
134
135 public void addTeamUsers(long teamId, long[] userIds)
136 throws PortalException, SystemException {
137
138 TeamPermissionUtil.check(
139 getPermissionChecker(), teamId, ActionKeys.ASSIGN_MEMBERS);
140
141 userLocalService.addTeamUsers(teamId, userIds);
142 }
143
144 public void addUserGroupUsers(long userGroupId, long[] userIds)
145 throws PortalException, SystemException {
146
147 UserGroupPermissionUtil.check(
148 getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
149
150 userLocalService.addUserGroupUsers(userGroupId, userIds);
151 }
152
153 public User addUser(
154 long companyId, boolean autoPassword, String password1,
155 String password2, boolean autoScreenName, String screenName,
156 String emailAddress, long facebookId, String openId, Locale locale,
157 String firstName, String middleName, String lastName, int prefixId,
158 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
159 int birthdayYear, String jobTitle, long[] groupIds,
160 long[] organizationIds, long[] roleIds, long[] userGroupIds,
161 boolean sendEmail, ServiceContext serviceContext)
162 throws PortalException, SystemException {
163
164 Company company = companyPersistence.findByPrimaryKey(companyId);
165
166 long creatorUserId = 0;
167
168 try {
169 creatorUserId = getUserId();
170 }
171 catch (PrincipalException pe) {
172 }
173
174 if ((creatorUserId != 0) || !company.isStrangers()) {
175 if (!PortalPermissionUtil.contains(
176 getPermissionChecker(), ActionKeys.ADD_USER) &&
177 !UserPermissionUtil.contains(
178 getPermissionChecker(), 0, organizationIds,
179 ActionKeys.ADD_USER)) {
180
181 throw new PrincipalException();
182 }
183 }
184
185 if (creatorUserId == 0) {
186 if (!company.isStrangersWithMx() &&
187 company.hasCompanyMx(emailAddress)) {
188
189 throw new ReservedUserEmailAddressException();
190 }
191 }
192
193 return userLocalService.addUser(
194 creatorUserId, companyId, autoPassword, password1, password2,
195 autoScreenName, screenName, emailAddress, facebookId, openId,
196 locale, firstName, middleName, lastName, prefixId, suffixId, male,
197 birthdayMonth, birthdayDay, birthdayYear, jobTitle, groupIds,
198 organizationIds, roleIds, userGroupIds, sendEmail, serviceContext);
199 }
200
201 public User addUser(
202 long companyId, boolean autoPassword, String password1,
203 String password2, boolean autoScreenName, String screenName,
204 String emailAddress, long facebookId, String openId, Locale locale,
205 String firstName, String middleName, String lastName, int prefixId,
206 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
207 int birthdayYear, String jobTitle, long[] groupIds,
208 long[] organizationIds, long[] roleIds, long[] userGroupIds,
209 boolean sendEmail, List<Address> addresses,
210 List<EmailAddress> emailAddresses, List<Phone> phones,
211 List<Website> websites,
212 List<AnnouncementsDelivery> announcementsDelivers,
213 ServiceContext serviceContext)
214 throws PortalException, SystemException {
215
216 User user = addUser(
217 companyId, autoPassword, password1, password2, autoScreenName,
218 screenName, emailAddress, facebookId, openId, locale, firstName,
219 middleName, lastName, prefixId, suffixId, male, birthdayMonth,
220 birthdayDay, birthdayYear, jobTitle, groupIds, organizationIds,
221 roleIds, userGroupIds, sendEmail, serviceContext);
222
223 EnterpriseAdminUtil.updateAddresses(
224 Contact.class.getName(), user.getContactId(), addresses);
225
226 EnterpriseAdminUtil.updateEmailAddresses(
227 Contact.class.getName(), user.getContactId(), emailAddresses);
228
229 EnterpriseAdminUtil.updatePhones(
230 Contact.class.getName(), user.getContactId(), phones);
231
232 EnterpriseAdminUtil.updateWebsites(
233 Contact.class.getName(), user.getContactId(), websites);
234
235 updateAnnouncementsDeliveries(user.getUserId(), announcementsDelivers);
236
237 return user;
238 }
239
240 public void deletePortrait(long userId)
241 throws PortalException, SystemException {
242
243 UserPermissionUtil.check(
244 getPermissionChecker(), userId, ActionKeys.UPDATE);
245
246 userLocalService.deletePortrait(userId);
247 }
248
249 public void deleteRoleUser(long roleId, long userId)
250 throws PortalException, SystemException {
251
252 RolePermissionUtil.check(
253 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
254
255 userLocalService.deleteRoleUser(roleId, userId);
256 }
257
258 public void deleteUser(long userId)
259 throws PortalException, SystemException {
260
261 if (getUserId() == userId) {
262 throw new RequiredUserException();
263 }
264
265 UserPermissionUtil.check(
266 getPermissionChecker(), userId, ActionKeys.DELETE);
267
268 userLocalService.deleteUser(userId);
269 }
270
271 public long getDefaultUserId(long companyId)
272 throws PortalException, SystemException {
273
274 return userLocalService.getDefaultUserId(companyId);
275 }
276
277 public long[] getGroupUserIds(long groupId) throws SystemException {
278 return userLocalService.getGroupUserIds(groupId);
279 }
280
281 public long[] getOrganizationUserIds(long organizationId)
282 throws SystemException {
283
284 return userLocalService.getOrganizationUserIds(organizationId);
285 }
286
287 public long[] getRoleUserIds(long roleId) throws SystemException {
288 return userLocalService.getRoleUserIds(roleId);
289 }
290
291 public User getUserByEmailAddress(long companyId, String emailAddress)
292 throws PortalException, SystemException {
293
294 User user = userLocalService.getUserByEmailAddress(
295 companyId, emailAddress);
296
297 UserPermissionUtil.check(
298 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
299
300 return user;
301 }
302
303 public User getUserById(long userId)
304 throws PortalException, SystemException {
305
306 User user = userLocalService.getUserById(userId);
307
308 UserPermissionUtil.check(
309 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
310
311 return user;
312 }
313
314 public User getUserByScreenName(long companyId, String screenName)
315 throws PortalException, SystemException {
316
317 User user = userLocalService.getUserByScreenName(
318 companyId, screenName);
319
320 UserPermissionUtil.check(
321 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
322
323 return user;
324 }
325
326 public long getUserIdByEmailAddress(long companyId, String emailAddress)
327 throws PortalException, SystemException {
328
329 User user = getUserByEmailAddress(companyId, emailAddress);
330
331 return user.getUserId();
332 }
333
334 public long getUserIdByScreenName(long companyId, String screenName)
335 throws PortalException, SystemException {
336
337 User user = getUserByScreenName(companyId, screenName);
338
339 return user.getUserId();
340 }
341
342 public boolean hasGroupUser(long groupId, long userId)
343 throws SystemException {
344
345 return userLocalService.hasGroupUser(groupId, userId);
346 }
347
348 public boolean hasRoleUser(long roleId, long userId)
349 throws SystemException {
350
351 return userLocalService.hasRoleUser(roleId, userId);
352 }
353
354 public boolean hasRoleUser(
355 long companyId, String name, long userId, boolean inherited)
356 throws PortalException, SystemException {
357
358 return userLocalService.hasRoleUser(companyId, name, userId, inherited);
359 }
360
361 public void setRoleUsers(long roleId, long[] userIds)
362 throws PortalException, SystemException {
363
364 RolePermissionUtil.check(
365 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
366
367 userLocalService.setRoleUsers(roleId, userIds);
368 }
369
370 public void setUserGroupUsers(long userGroupId, long[] userIds)
371 throws PortalException, SystemException {
372
373 UserGroupPermissionUtil.check(
374 getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
375
376 userLocalService.setUserGroupUsers(userGroupId, userIds);
377 }
378
379 public void unsetGroupUsers(long groupId, long[] userIds)
380 throws PortalException, SystemException {
381
382 try {
383 GroupPermissionUtil.check(
384 getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
385 }
386 catch (PrincipalException pe) {
387
388
389
390 boolean hasPermission = false;
391
392 if (userIds.length == 0) {
393 hasPermission = true;
394 }
395 else if (userIds.length == 1) {
396 User user = getUser();
397
398 if (user.getUserId() == userIds[0]) {
399 Group group = groupPersistence.findByPrimaryKey(groupId);
400
401 if (user.getCompanyId() == group.getCompanyId()) {
402 int type = group.getType();
403
404 if ((type == GroupConstants.TYPE_COMMUNITY_OPEN) ||
405 (type ==
406 GroupConstants.TYPE_COMMUNITY_RESTRICTED)) {
407
408 hasPermission = true;
409 }
410 }
411 }
412 }
413
414 if (!hasPermission) {
415 throw new PrincipalException();
416 }
417 }
418
419 userLocalService.unsetGroupUsers(groupId, userIds);
420 }
421
422 public void unsetOrganizationUsers(long organizationId, long[] userIds)
423 throws PortalException, SystemException {
424
425 OrganizationPermissionUtil.check(
426 getPermissionChecker(), organizationId, ActionKeys.ASSIGN_MEMBERS);
427
428 userLocalService.unsetOrganizationUsers(organizationId, userIds);
429 }
430
431 public void unsetPasswordPolicyUsers(long passwordPolicyId, long[] userIds)
432 throws PortalException, SystemException {
433
434 PasswordPolicyPermissionUtil.check(
435 getPermissionChecker(), passwordPolicyId,
436 ActionKeys.ASSIGN_MEMBERS);
437
438 userLocalService.unsetPasswordPolicyUsers(passwordPolicyId, userIds);
439 }
440
441 public void unsetRoleUsers(long roleId, long[] userIds)
442 throws PortalException, SystemException {
443
444 RolePermissionUtil.check(
445 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
446
447 userLocalService.unsetRoleUsers(roleId, userIds);
448 }
449
450 public void unsetTeamUsers(long teamId, long[] userIds)
451 throws PortalException, SystemException {
452
453 TeamPermissionUtil.check(
454 getPermissionChecker(), teamId, ActionKeys.ASSIGN_MEMBERS);
455
456 userLocalService.unsetTeamUsers(teamId, userIds);
457 }
458
459 public void unsetUserGroupUsers(long userGroupId, long[] userIds)
460 throws PortalException, SystemException {
461
462 UserGroupPermissionUtil.check(
463 getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
464
465 userLocalService.unsetUserGroupUsers(userGroupId, userIds);
466 }
467
468 public User updateActive(long userId, boolean active)
469 throws PortalException, SystemException {
470
471 if ((getUserId() == userId) && !active) {
472 throw new RequiredUserException();
473 }
474
475 UserPermissionUtil.check(
476 getPermissionChecker(), userId, ActionKeys.DELETE);
477
478 return userLocalService.updateActive(userId, active);
479 }
480
481 public User updateAgreedToTermsOfUse(
482 long userId, boolean agreedToTermsOfUse)
483 throws PortalException, SystemException {
484
485 UserPermissionUtil.check(
486 getPermissionChecker(), userId, ActionKeys.UPDATE);
487
488 return userLocalService.updateAgreedToTermsOfUse(
489 userId, agreedToTermsOfUse);
490 }
491
492 public void updateEmailAddress(
493 long userId, String password, String emailAddress1,
494 String emailAddress2)
495 throws PortalException, SystemException {
496
497 UserPermissionUtil.check(
498 getPermissionChecker(), userId, ActionKeys.UPDATE);
499
500 userLocalService.updateEmailAddress(
501 userId, password, emailAddress1, emailAddress2);
502 }
503
504 public User updateLockout(long userId, boolean lockout)
505 throws PortalException, SystemException {
506
507 UserPermissionUtil.check(
508 getPermissionChecker(), userId, ActionKeys.DELETE);
509
510 return userLocalService.updateLockoutById(userId, lockout);
511 }
512
513 public void updateOpenId(long userId, String openId)
514 throws PortalException, SystemException {
515
516 UserPermissionUtil.check(
517 getPermissionChecker(), userId, ActionKeys.UPDATE);
518
519 userLocalService.updateOpenId(userId, openId);
520 }
521
522 public void updateOrganizations(long userId, long[] organizationIds)
523 throws PortalException, SystemException {
524
525 UserPermissionUtil.check(
526 getPermissionChecker(), userId, ActionKeys.UPDATE);
527
528 userLocalService.updateOrganizations(userId, organizationIds);
529 }
530
531 public User updatePassword(
532 long userId, String password1, String password2,
533 boolean passwordReset)
534 throws PortalException, SystemException {
535
536 UserPermissionUtil.check(
537 getPermissionChecker(), userId, ActionKeys.UPDATE);
538
539 return userLocalService.updatePassword(
540 userId, password1, password2, passwordReset);
541 }
542
543 public void updatePortrait(long userId, byte[] bytes)
544 throws PortalException, SystemException {
545
546 UserPermissionUtil.check(
547 getPermissionChecker(), userId, ActionKeys.UPDATE);
548
549 userLocalService.updatePortrait(userId, bytes);
550 }
551
552 public void updateReminderQuery(
553 long userId, String question, String answer)
554 throws PortalException, SystemException {
555
556 UserPermissionUtil.check(
557 getPermissionChecker(), userId, ActionKeys.UPDATE);
558
559 userLocalService.updateReminderQuery(userId, question, answer);
560 }
561
562 public void updateScreenName(long userId, String screenName)
563 throws PortalException, SystemException {
564
565 UserPermissionUtil.check(
566 getPermissionChecker(), userId, ActionKeys.UPDATE);
567
568 userLocalService.updateScreenName(userId, screenName);
569 }
570
571 public User updateUser(
572 long userId, String oldPassword, String newPassword1,
573 String newPassword2, boolean passwordReset,
574 String reminderQueryQuestion, String reminderQueryAnswer,
575 String screenName, String emailAddress, long facebookId,
576 String openId, String languageId, String timeZoneId,
577 String greeting, String comments, String firstName,
578 String middleName, String lastName, int prefixId, int suffixId,
579 boolean male, int birthdayMonth, int birthdayDay, int birthdayYear,
580 String smsSn, String aimSn, String facebookSn, String icqSn,
581 String jabberSn, String msnSn, String mySpaceSn, String skypeSn,
582 String twitterSn, String ymSn, String jobTitle, long[] groupIds,
583 long[] organizationIds, long[] roleIds,
584 List<UserGroupRole> userGroupRoles, long[] userGroupIds,
585 ServiceContext serviceContext)
586 throws PortalException, SystemException {
587
588 UserPermissionUtil.check(
589 getPermissionChecker(), userId, organizationIds, ActionKeys.UPDATE);
590
591 long curUserId = getUserId();
592
593 if (curUserId == userId) {
594 User user = userPersistence.findByPrimaryKey(userId);
595
596 screenName = screenName.trim().toLowerCase();
597
598 if (!screenName.equalsIgnoreCase(user.getScreenName())) {
599 validateScreenName(user, screenName);
600 }
601
602 emailAddress = emailAddress.trim().toLowerCase();
603
604 if (!emailAddress.equalsIgnoreCase(user.getEmailAddress())) {
605 validateEmailAddress(user, emailAddress);
606 }
607 }
608
609 if (groupIds != null) {
610 groupIds = checkGroups(userId, groupIds);
611 }
612
613 if (organizationIds != null) {
614 organizationIds = checkOrganizations(userId, organizationIds);
615 }
616
617 if (roleIds != null) {
618 roleIds = checkRoles(userId, roleIds);
619 }
620
621 if (userGroupRoles != null) {
622 userGroupRoles = checkUserGroupRoles(userId, userGroupRoles);
623 }
624
625 return userLocalService.updateUser(
626 userId, oldPassword, newPassword1, newPassword2, passwordReset,
627 reminderQueryQuestion, reminderQueryAnswer, screenName,
628 emailAddress, facebookId, openId, languageId, timeZoneId, greeting,
629 comments, firstName, middleName, lastName, prefixId, suffixId, male,
630 birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn, facebookSn,
631 icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn, ymSn,
632 jobTitle, groupIds, organizationIds, roleIds, userGroupRoles,
633 userGroupIds, serviceContext);
634 }
635
636 public User updateUser(
637 long userId, String oldPassword, String newPassword1,
638 String newPassword2, boolean passwordReset,
639 String reminderQueryQuestion, String reminderQueryAnswer,
640 String screenName, String emailAddress, long facebookId,
641 String openId, String languageId, String timeZoneId,
642 String greeting, String comments, String firstName,
643 String middleName, String lastName, int prefixId, int suffixId,
644 boolean male, int birthdayMonth, int birthdayDay, int birthdayYear,
645 String smsSn, String aimSn, String facebookSn, String icqSn,
646 String jabberSn, String msnSn, String mySpaceSn, String skypeSn,
647 String twitterSn, String ymSn, String jobTitle, long[] groupIds,
648 long[] organizationIds, long[] roleIds,
649 List<UserGroupRole> userGroupRoles, long[] userGroupIds,
650 List<Address> addresses, List<EmailAddress> emailAddresses,
651 List<Phone> phones, List<Website> websites,
652 List<AnnouncementsDelivery> announcementsDelivers,
653 ServiceContext serviceContext)
654 throws PortalException, SystemException {
655
656 User user = updateUser(
657 userId, oldPassword, newPassword1, newPassword2, passwordReset,
658 reminderQueryQuestion, reminderQueryAnswer, screenName,
659 emailAddress, facebookId, openId, languageId, timeZoneId, greeting,
660 comments, firstName, middleName, lastName, prefixId, suffixId, male,
661 birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn, facebookSn,
662 icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn, ymSn,
663 jobTitle, groupIds, organizationIds, roleIds,
664 userGroupRoles, userGroupIds, serviceContext);
665
666 EnterpriseAdminUtil.updateAddresses(
667 Contact.class.getName(), user.getContactId(), addresses);
668
669 EnterpriseAdminUtil.updateEmailAddresses(
670 Contact.class.getName(), user.getContactId(), emailAddresses);
671
672 EnterpriseAdminUtil.updatePhones(
673 Contact.class.getName(), user.getContactId(), phones);
674
675 EnterpriseAdminUtil.updateWebsites(
676 Contact.class.getName(), user.getContactId(), websites);
677
678 updateAnnouncementsDeliveries(user.getUserId(), announcementsDelivers);
679
680 return user;
681 }
682
683 protected long[] checkGroups(long userId, long[] groupIds)
684 throws PortalException, SystemException {
685
686
687
688
689 List<Group> oldGroups = groupLocalService.getUserGroups(userId);
690 long[] oldGroupIds = new long[oldGroups.size()];
691
692 for (int i = 0; i < oldGroups.size(); i++) {
693 Group group = oldGroups.get(i);
694
695 if (!ArrayUtil.contains(groupIds, group.getGroupId()) &&
696 !GroupPermissionUtil.contains(
697 getPermissionChecker(), group.getGroupId(),
698 ActionKeys.ASSIGN_MEMBERS)) {
699
700 groupIds = ArrayUtil.append(groupIds, group.getGroupId());
701 }
702
703 oldGroupIds[i] = group.getGroupId();
704 }
705
706 for (long groupId : groupIds) {
707 if (!ArrayUtil.contains(oldGroupIds, groupId)) {
708 GroupPermissionUtil.check(
709 getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
710 }
711 }
712
713 return groupIds;
714 }
715
716 protected long[] checkOrganizations(long userId, long[] organizationIds)
717 throws PortalException, SystemException {
718
719
720
721
722
723 List<Organization> oldOrganizations =
724 organizationLocalService.getUserOrganizations(userId);
725 long[] oldOrganizationIds = new long[oldOrganizations.size()];
726
727 for (int i = 0; i < oldOrganizations.size(); i++) {
728 Organization organization = oldOrganizations.get(i);
729
730 if (!ArrayUtil.contains(
731 organizationIds, organization.getOrganizationId()) &&
732 !OrganizationPermissionUtil.contains(
733 getPermissionChecker(), organization.getOrganizationId(),
734 ActionKeys.ASSIGN_MEMBERS)) {
735
736 organizationIds = ArrayUtil.append(
737 organizationIds, organization.getOrganizationId());
738 }
739
740 oldOrganizationIds[i] = organization.getOrganizationId();
741 }
742
743 for (long organizationId : organizationIds) {
744 if (!ArrayUtil.contains(oldOrganizationIds, organizationId)) {
745 OrganizationPermissionUtil.check(
746 getPermissionChecker(), organizationId,
747 ActionKeys.ASSIGN_MEMBERS);
748 }
749 }
750
751 return organizationIds;
752 }
753
754 protected long[] checkRoles(long userId, long[] roleIds)
755 throws PrincipalException, SystemException {
756
757
758
759
760 List<Role> oldRoles = roleLocalService.getUserRoles(userId);
761 long[] oldRoleIds = new long[oldRoles.size()];
762
763 for (int i = 0; i < oldRoles.size(); i++) {
764 Role role = oldRoles.get(i);
765
766 if (!ArrayUtil.contains(roleIds, role.getRoleId()) &&
767 !RolePermissionUtil.contains(
768 getPermissionChecker(), role.getRoleId(),
769 ActionKeys.ASSIGN_MEMBERS)) {
770
771 roleIds = ArrayUtil.append(roleIds, role.getRoleId());
772 }
773
774 oldRoleIds[i] = role.getRoleId();
775 }
776
777 for (long roleId : roleIds) {
778 if (!ArrayUtil.contains(oldRoleIds, roleId)) {
779 RolePermissionUtil.check(
780 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
781 }
782 }
783
784 return roleIds;
785 }
786
787 protected List<UserGroupRole> checkUserGroupRoles(
788 long userId, List<UserGroupRole> userGroupRoles)
789 throws PortalException, SystemException {
790
791
792
793
794 List<UserGroupRole> oldUserGroupRoles =
795 userGroupRoleLocalService.getUserGroupRoles(userId);
796
797 for (UserGroupRole oldUserGroupRole : oldUserGroupRoles) {
798 if (!userGroupRoles.contains(oldUserGroupRole) &&
799 (!GroupPermissionUtil.contains(
800 getPermissionChecker(), oldUserGroupRole.getGroupId(),
801 ActionKeys.ASSIGN_MEMBERS) ||
802 !RolePermissionUtil.contains(
803 getPermissionChecker(), oldUserGroupRole.getRoleId(),
804 ActionKeys.ASSIGN_MEMBERS))) {
805
806 userGroupRoles.add(oldUserGroupRole);
807 }
808 }
809
810 for (UserGroupRole userGroupRole : userGroupRoles) {
811 if (!oldUserGroupRoles.contains(userGroupRole)) {
812
813 if (!GroupPermissionUtil.contains(
814 getPermissionChecker(), userGroupRole.getGroupId(),
815 ActionKeys.ASSIGN_MEMBERS) ||
816 !RolePermissionUtil.contains(
817 getPermissionChecker(), userGroupRole.getRoleId(),
818 ActionKeys.ASSIGN_MEMBERS)) {
819
820 throw new PrincipalException();
821 }
822 }
823 }
824
825 return userGroupRoles;
826 }
827
828 protected void updateAnnouncementsDeliveries(
829 long userId, List<AnnouncementsDelivery> announcementsDeliveries)
830 throws PortalException, SystemException {
831
832 for (AnnouncementsDelivery announcementsDelivery :
833 announcementsDeliveries) {
834
835 announcementsDeliveryService.updateDelivery(
836 userId, announcementsDelivery.getType(),
837 announcementsDelivery.getEmail(),
838 announcementsDelivery.getSms(),
839 announcementsDelivery.getWebsite());
840 }
841 }
842
843 protected void validateEmailAddress(User user, String emailAddress)
844 throws PortalException, SystemException {
845
846 PermissionChecker permissionChecker = getPermissionChecker();
847
848 if (!EnterpriseAdminUtil.hasUpdateEmailAddress(
849 permissionChecker, user)) {
850
851 throw new UserEmailAddressException();
852 }
853
854 if (!user.hasCompanyMx() && user.hasCompanyMx(emailAddress)) {
855 Company company = companyPersistence.findByPrimaryKey(
856 user.getCompanyId());
857
858 if (!company.isStrangersWithMx()) {
859 throw new ReservedUserEmailAddressException();
860 }
861 }
862 }
863
864 protected void validateScreenName(User user, String screenName)
865 throws PortalException, SystemException {
866
867 PermissionChecker permissionChecker = getPermissionChecker();
868
869 if (!EnterpriseAdminUtil.hasUpdateScreenName(permissionChecker, user)) {
870 throw new UserScreenNameException();
871 }
872 }
873
874 protected void validateOrganizationUsers(long[] userIds)
875 throws PortalException, SystemException {
876
877 PermissionChecker permissionChecker = getPermissionChecker();
878
879 if (!PropsValues.ORGANIZATIONS_ASSIGNMENT_STRICT ||
880 permissionChecker.isCompanyAdmin()) {
881
882 return;
883 }
884
885 List<Organization> organizations =
886 organizationLocalService.getUserOrganizations(
887 permissionChecker.getUserId());
888
889 for (long userId : userIds) {
890 boolean allowed = false;
891
892 for (Organization organization : organizations) {
893 boolean manageUsers = OrganizationPermissionUtil.contains(
894 permissionChecker, organization, ActionKeys.MANAGE_USERS);
895 boolean manageSuborganizations =
896 OrganizationPermissionUtil.contains(
897 permissionChecker, organization,
898 ActionKeys.MANAGE_SUBORGANIZATIONS);
899
900 if (!manageUsers && !manageSuborganizations) {
901 continue;
902 }
903
904 boolean inherited = false;
905 boolean includeSpecifiedOrganization = false;
906
907 if (manageUsers && manageSuborganizations) {
908 inherited = true;
909 includeSpecifiedOrganization = true;
910 }
911 else if (!manageUsers && manageSuborganizations) {
912 inherited = true;
913 includeSpecifiedOrganization = false;
914 }
915
916 if (organizationLocalService.hasUserOrganization(
917 userId, organization.getOrganizationId(), inherited,
918 false, includeSpecifiedOrganization)) {
919
920 allowed = true;
921
922 break;
923 }
924 }
925
926 if (!allowed) {
927 throw new PrincipalException();
928 }
929 }
930 }
931
932 }