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.search.Indexer;
024 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
025 import com.liferay.portal.kernel.util.ArrayUtil;
026 import com.liferay.portal.kernel.util.ParamUtil;
027 import com.liferay.portal.kernel.workflow.WorkflowConstants;
028 import com.liferay.portal.kernel.workflow.WorkflowThreadLocal;
029 import com.liferay.portal.model.Address;
030 import com.liferay.portal.model.Company;
031 import com.liferay.portal.model.CompanyConstants;
032 import com.liferay.portal.model.Contact;
033 import com.liferay.portal.model.EmailAddress;
034 import com.liferay.portal.model.Group;
035 import com.liferay.portal.model.GroupConstants;
036 import com.liferay.portal.model.Organization;
037 import com.liferay.portal.model.Phone;
038 import com.liferay.portal.model.Role;
039 import com.liferay.portal.model.User;
040 import com.liferay.portal.model.UserGroup;
041 import com.liferay.portal.model.UserGroupRole;
042 import com.liferay.portal.model.Website;
043 import com.liferay.portal.security.auth.PrincipalException;
044 import com.liferay.portal.security.permission.ActionKeys;
045 import com.liferay.portal.security.permission.PermissionChecker;
046 import com.liferay.portal.service.ServiceContext;
047 import com.liferay.portal.service.base.UserServiceBaseImpl;
048 import com.liferay.portal.service.permission.GroupPermissionUtil;
049 import com.liferay.portal.service.permission.OrganizationPermissionUtil;
050 import com.liferay.portal.service.permission.PasswordPolicyPermissionUtil;
051 import com.liferay.portal.service.permission.PortalPermissionUtil;
052 import com.liferay.portal.service.permission.RolePermissionUtil;
053 import com.liferay.portal.service.permission.TeamPermissionUtil;
054 import com.liferay.portal.service.permission.UserGroupPermissionUtil;
055 import com.liferay.portal.service.permission.UserGroupRolePermissionUtil;
056 import com.liferay.portal.service.permission.UserPermissionUtil;
057 import com.liferay.portal.util.PropsValues;
058 import com.liferay.portlet.announcements.model.AnnouncementsDelivery;
059 import com.liferay.portlet.usersadmin.util.UsersAdminUtil;
060
061 import java.util.List;
062 import java.util.Locale;
063
064
073 public class UserServiceImpl extends UserServiceBaseImpl {
074
075
086 public void addGroupUsers(
087 long groupId, long[] userIds, ServiceContext serviceContext)
088 throws PortalException, SystemException {
089
090 try {
091 GroupPermissionUtil.check(
092 getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
093 }
094 catch (PrincipalException pe) {
095
096
097
098 boolean hasPermission = false;
099
100 if (userIds.length == 0) {
101 hasPermission = true;
102 }
103 else if (userIds.length == 1) {
104 User user = getUser();
105
106 if (user.getUserId() == userIds[0]) {
107 Group group = groupPersistence.findByPrimaryKey(groupId);
108
109 if (user.getCompanyId() == group.getCompanyId()) {
110 int type = group.getType();
111
112 if (type == GroupConstants.TYPE_SITE_OPEN) {
113 hasPermission = true;
114 }
115 }
116 }
117 }
118
119 if (!hasPermission) {
120 throw new PrincipalException();
121 }
122 }
123
124 userLocalService.addGroupUsers(groupId, userIds);
125 }
126
127
138 public void addOrganizationUsers(long organizationId, long[] userIds)
139 throws PortalException, SystemException {
140
141 OrganizationPermissionUtil.check(
142 getPermissionChecker(), organizationId, ActionKeys.ASSIGN_MEMBERS);
143
144 validateOrganizationUsers(userIds);
145
146 userLocalService.addOrganizationUsers(organizationId, userIds);
147 }
148
149
159 public void addPasswordPolicyUsers(long passwordPolicyId, long[] userIds)
160 throws PortalException, SystemException {
161
162 PasswordPolicyPermissionUtil.check(
163 getPermissionChecker(), passwordPolicyId,
164 ActionKeys.ASSIGN_MEMBERS);
165
166 userLocalService.addPasswordPolicyUsers(passwordPolicyId, userIds);
167 }
168
169
179 public void addRoleUsers(long roleId, long[] userIds)
180 throws PortalException, SystemException {
181
182 RolePermissionUtil.check(
183 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
184
185 userLocalService.addRoleUsers(roleId, userIds);
186 }
187
188
198 public void addTeamUsers(long teamId, long[] userIds)
199 throws PortalException, SystemException {
200
201 TeamPermissionUtil.check(
202 getPermissionChecker(), teamId, ActionKeys.ASSIGN_MEMBERS);
203
204 userLocalService.addTeamUsers(teamId, userIds);
205 }
206
207
256 public User addUser(
257 long companyId, boolean autoPassword, String password1,
258 String password2, boolean autoScreenName, String screenName,
259 String emailAddress, long facebookId, String openId, Locale locale,
260 String firstName, String middleName, String lastName, int prefixId,
261 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
262 int birthdayYear, String jobTitle, long[] groupIds,
263 long[] organizationIds, long[] roleIds, long[] userGroupIds,
264 boolean sendEmail, ServiceContext serviceContext)
265 throws PortalException, SystemException {
266
267 boolean workflowEnabled = WorkflowThreadLocal.isEnabled();
268
269 try {
270 WorkflowThreadLocal.setEnabled(false);
271
272 return addUserWithWorkflow(
273 companyId, autoPassword, password1, password2, autoScreenName,
274 screenName, emailAddress, facebookId, openId, locale, firstName,
275 middleName, lastName, prefixId, suffixId, male, birthdayMonth,
276 birthdayDay, birthdayYear, jobTitle, groupIds, organizationIds,
277 roleIds, userGroupIds, sendEmail, serviceContext);
278 }
279 finally {
280 WorkflowThreadLocal.setEnabled(workflowEnabled);
281 }
282 }
283
284
338 public User addUser(
339 long companyId, boolean autoPassword, String password1,
340 String password2, boolean autoScreenName, String screenName,
341 String emailAddress, long facebookId, String openId, Locale locale,
342 String firstName, String middleName, String lastName, int prefixId,
343 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
344 int birthdayYear, String jobTitle, long[] groupIds,
345 long[] organizationIds, long[] roleIds, long[] userGroupIds,
346 List<Address> addresses, List<EmailAddress> emailAddresses,
347 List<Phone> phones, List<Website> websites,
348 List<AnnouncementsDelivery> announcementsDelivers,
349 boolean sendEmail, ServiceContext serviceContext)
350 throws PortalException, SystemException {
351
352 boolean workflowEnabled = WorkflowThreadLocal.isEnabled();
353
354 try {
355 WorkflowThreadLocal.setEnabled(false);
356
357 return addUserWithWorkflow(
358 companyId, autoPassword, password1, password2, autoScreenName,
359 screenName, emailAddress, facebookId, openId, locale, firstName,
360 middleName, lastName, prefixId, suffixId, male, birthdayMonth,
361 birthdayDay, birthdayYear, jobTitle, groupIds, organizationIds,
362 roleIds, userGroupIds, addresses, emailAddresses, phones,
363 websites, announcementsDelivers, sendEmail, serviceContext);
364 }
365 finally {
366 WorkflowThreadLocal.setEnabled(workflowEnabled);
367 }
368 }
369
370
380 public void addUserGroupUsers(long userGroupId, long[] userIds)
381 throws PortalException, SystemException {
382
383 UserGroupPermissionUtil.check(
384 getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
385
386 userLocalService.addUserGroupUsers(userGroupId, userIds);
387 }
388
389
438 public User addUserWithWorkflow(
439 long companyId, boolean autoPassword, String password1,
440 String password2, boolean autoScreenName, String screenName,
441 String emailAddress, long facebookId, String openId, Locale locale,
442 String firstName, String middleName, String lastName, int prefixId,
443 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
444 int birthdayYear, String jobTitle, long[] groupIds,
445 long[] organizationIds, long[] roleIds, long[] userGroupIds,
446 boolean sendEmail, ServiceContext serviceContext)
447 throws PortalException, SystemException {
448
449 long creatorUserId = 0;
450
451 try {
452 creatorUserId = getGuestOrUserId();
453 }
454 catch (PrincipalException pe) {
455 }
456
457 checkAddUserPermission(
458 creatorUserId, companyId, emailAddress, groupIds, organizationIds,
459 roleIds, userGroupIds, serviceContext);
460
461 return userLocalService.addUserWithWorkflow(
462 creatorUserId, companyId, autoPassword, password1, password2,
463 autoScreenName, screenName, emailAddress, facebookId, openId,
464 locale, firstName, middleName, lastName, prefixId, suffixId, male,
465 birthdayMonth, birthdayDay, birthdayYear, jobTitle, groupIds,
466 organizationIds, roleIds, userGroupIds, sendEmail, serviceContext);
467 }
468
469
523 public User addUserWithWorkflow(
524 long companyId, boolean autoPassword, String password1,
525 String password2, boolean autoScreenName, String screenName,
526 String emailAddress, long facebookId, String openId, Locale locale,
527 String firstName, String middleName, String lastName, int prefixId,
528 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
529 int birthdayYear, String jobTitle, long[] groupIds,
530 long[] organizationIds, long[] roleIds, long[] userGroupIds,
531 List<Address> addresses, List<EmailAddress> emailAddresses,
532 List<Phone> phones, List<Website> websites,
533 List<AnnouncementsDelivery> announcementsDelivers,
534 boolean sendEmail, ServiceContext serviceContext)
535 throws PortalException, SystemException {
536
537 boolean indexingEnabled = serviceContext.isIndexingEnabled();
538
539 serviceContext.setIndexingEnabled(false);
540
541 try {
542 User user = addUserWithWorkflow(
543 companyId, autoPassword, password1, password2, autoScreenName,
544 screenName, emailAddress, facebookId, openId, locale, firstName,
545 middleName, lastName, prefixId, suffixId, male, birthdayMonth,
546 birthdayDay, birthdayYear, jobTitle, groupIds, organizationIds,
547 roleIds, userGroupIds, sendEmail, serviceContext);
548
549 UsersAdminUtil.updateAddresses(
550 Contact.class.getName(), user.getContactId(), addresses);
551
552 UsersAdminUtil.updateEmailAddresses(
553 Contact.class.getName(), user.getContactId(), emailAddresses);
554
555 UsersAdminUtil.updatePhones(
556 Contact.class.getName(), user.getContactId(), phones);
557
558 UsersAdminUtil.updateWebsites(
559 Contact.class.getName(), user.getContactId(), websites);
560
561 updateAnnouncementsDeliveries(
562 user.getUserId(), announcementsDelivers);
563
564 if (indexingEnabled) {
565 Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
566 User.class);
567
568 indexer.reindex(user);
569 }
570
571 return user;
572 }
573 finally {
574 serviceContext.setIndexingEnabled(indexingEnabled);
575 }
576 }
577
578
587 public void deletePortrait(long userId)
588 throws PortalException, SystemException {
589
590 UserPermissionUtil.check(
591 getPermissionChecker(), userId, ActionKeys.UPDATE);
592
593 userLocalService.deletePortrait(userId);
594 }
595
596
606 public void deleteRoleUser(long roleId, long userId)
607 throws PortalException, SystemException {
608
609 RolePermissionUtil.check(
610 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
611
612 userLocalService.deleteRoleUser(roleId, userId);
613 }
614
615
623 public void deleteUser(long userId)
624 throws PortalException, SystemException {
625
626 if (getUserId() == userId) {
627 throw new RequiredUserException();
628 }
629
630 UserPermissionUtil.check(
631 getPermissionChecker(), userId, ActionKeys.DELETE);
632
633 userLocalService.deleteUser(userId);
634 }
635
636 public List<User> getCompanyUsers(long companyId, int start, int end)
637 throws PortalException, SystemException {
638
639 PermissionChecker permissionChecker = getPermissionChecker();
640
641 if (!permissionChecker.isCompanyAdmin(companyId)) {
642 throw new PrincipalException();
643 }
644
645 return userPersistence.findByCompanyId(companyId, start, end);
646 }
647
648 public int getCompanyUsersCount(long companyId)
649 throws PortalException, SystemException {
650
651 PermissionChecker permissionChecker = getPermissionChecker();
652
653 if (!permissionChecker.isCompanyAdmin(companyId)) {
654 throw new PrincipalException();
655 }
656
657 return userPersistence.countByCompanyId(companyId);
658 }
659
660
669 public long[] getGroupUserIds(long groupId)
670 throws PortalException, SystemException {
671
672 GroupPermissionUtil.check(
673 getPermissionChecker(), groupId, ActionKeys.VIEW_MEMBERS);
674
675 return userLocalService.getGroupUserIds(groupId);
676 }
677
678
687 public List<User> getGroupUsers(long groupId)
688 throws PortalException, SystemException {
689
690 GroupPermissionUtil.check(
691 getPermissionChecker(), groupId, ActionKeys.VIEW_MEMBERS);
692
693 return userLocalService.getGroupUsers(groupId);
694 }
695
696
705 public long[] getOrganizationUserIds(long organizationId)
706 throws PortalException, SystemException {
707
708 OrganizationPermissionUtil.check(
709 getPermissionChecker(), organizationId, ActionKeys.VIEW_MEMBERS);
710
711 return userLocalService.getOrganizationUserIds(organizationId);
712 }
713
714
723 public List<User> getOrganizationUsers(long organizationId)
724 throws PortalException, SystemException {
725
726 OrganizationPermissionUtil.check(
727 getPermissionChecker(), organizationId, ActionKeys.VIEW_MEMBERS);
728
729 return userLocalService.getOrganizationUsers(organizationId);
730 }
731
732
741 public long[] getRoleUserIds(long roleId) throws
742 PortalException, SystemException {
743
744 RolePermissionUtil.check(
745 getPermissionChecker(), roleId, ActionKeys.VIEW);
746
747 return userLocalService.getRoleUserIds(roleId);
748 }
749
750
761 public User getUserByEmailAddress(long companyId, String emailAddress)
762 throws PortalException, SystemException {
763
764 User user = userLocalService.getUserByEmailAddress(
765 companyId, emailAddress);
766
767 UserPermissionUtil.check(
768 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
769
770 return user;
771 }
772
773
782 public User getUserById(long userId)
783 throws PortalException, SystemException {
784
785 User user = userPersistence.findByPrimaryKey(userId);
786
787 UserPermissionUtil.check(
788 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
789
790 return user;
791 }
792
793
803 public User getUserByScreenName(long companyId, String screenName)
804 throws PortalException, SystemException {
805
806 User user = userLocalService.getUserByScreenName(companyId, screenName);
807
808 UserPermissionUtil.check(
809 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
810
811 return user;
812 }
813
814 public List<User> getUserGroupUsers(long userGroupId)
815 throws PortalException, SystemException {
816
817 UserGroupPermissionUtil.check(
818 getPermissionChecker(), userGroupId, ActionKeys.VIEW_MEMBERS);
819
820 return userGroupPersistence.getUsers(userGroupId);
821 }
822
823
833 public long getUserIdByEmailAddress(long companyId, String emailAddress)
834 throws PortalException, SystemException {
835
836 User user = getUserByEmailAddress(companyId, emailAddress);
837
838 UserPermissionUtil.check(
839 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
840
841 return user.getUserId();
842 }
843
844
853 public long getUserIdByScreenName(long companyId, String screenName)
854 throws PortalException, SystemException {
855
856 User user = getUserByScreenName(companyId, screenName);
857
858 UserPermissionUtil.check(
859 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
860
861 return user.getUserId();
862 }
863
864
875 public boolean hasGroupUser(long groupId, long userId)
876 throws PortalException, SystemException {
877
878 try {
879 UserPermissionUtil.check(
880 getPermissionChecker(), userId, ActionKeys.VIEW);
881 }
882 catch (PrincipalException e) {
883 GroupPermissionUtil.check(
884 getPermissionChecker(), groupId, ActionKeys.VIEW_MEMBERS);
885 }
886
887 return userLocalService.hasGroupUser(groupId, userId);
888 }
889
890
901 public boolean hasRoleUser(long roleId, long userId)
902 throws PortalException, SystemException {
903
904 try {
905 UserPermissionUtil.check(
906 getPermissionChecker(), userId, ActionKeys.VIEW);
907 }
908 catch (PrincipalException e) {
909 RolePermissionUtil.check(
910 getPermissionChecker(), roleId, ActionKeys.VIEW_MEMBERS);
911 }
912
913 return userLocalService.hasRoleUser(roleId, userId);
914 }
915
916
931 public boolean hasRoleUser(
932 long companyId, String name, long userId, boolean inherited)
933 throws PortalException, SystemException {
934
935 try {
936 UserPermissionUtil.check(
937 getPermissionChecker(), userId, ActionKeys.VIEW);
938 }
939 catch (PrincipalException e) {
940 Role role = roleLocalService.getRole(companyId, name);
941
942 RolePermissionUtil.check(
943 getPermissionChecker(), role.getRoleId(),
944 ActionKeys.VIEW_MEMBERS);
945 }
946
947 return userLocalService.hasRoleUser(companyId, name, userId, inherited);
948 }
949
950
960 public void setRoleUsers(long roleId, long[] userIds)
961 throws PortalException, SystemException {
962
963 RolePermissionUtil.check(
964 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
965
966 userLocalService.setRoleUsers(roleId, userIds);
967 }
968
969
979 public void setUserGroupUsers(long userGroupId, long[] userIds)
980 throws PortalException, SystemException {
981
982 UserGroupPermissionUtil.check(
983 getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
984
985 userLocalService.setUserGroupUsers(userGroupId, userIds);
986 }
987
988
997 public void unsetGroupTeamsUsers(long groupId, long[] userIds)
998 throws PortalException, SystemException {
999
1000 UserGroupPermissionUtil.check(
1001 getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
1002
1003 userLocalService.unsetGroupTeamsUsers(groupId, userIds);
1004 }
1005
1006
1016 public void unsetGroupUsers(
1017 long groupId, long[] userIds, ServiceContext serviceContext)
1018 throws PortalException, SystemException {
1019
1020 try {
1021 GroupPermissionUtil.check(
1022 getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
1023 }
1024 catch (PrincipalException pe) {
1025
1026
1027
1028 boolean hasPermission = false;
1029
1030 if (userIds.length == 0) {
1031 hasPermission = true;
1032 }
1033 else if (userIds.length == 1) {
1034 User user = getUser();
1035
1036 if (user.getUserId() == userIds[0]) {
1037 Group group = groupPersistence.findByPrimaryKey(groupId);
1038
1039 if (user.getCompanyId() == group.getCompanyId()) {
1040 int type = group.getType();
1041
1042 if ((type == GroupConstants.TYPE_SITE_OPEN) ||
1043 (type == GroupConstants.TYPE_SITE_RESTRICTED)) {
1044
1045 hasPermission = true;
1046 }
1047 }
1048 }
1049 }
1050
1051 if (!hasPermission) {
1052 throw new PrincipalException();
1053 }
1054 }
1055
1056 userLocalService.unsetGroupUsers(groupId, userIds, serviceContext);
1057 }
1058
1059
1068 public void unsetOrganizationUsers(long organizationId, long[] userIds)
1069 throws PortalException, SystemException {
1070
1071 OrganizationPermissionUtil.check(
1072 getPermissionChecker(), organizationId, ActionKeys.ASSIGN_MEMBERS);
1073
1074 userLocalService.unsetOrganizationUsers(organizationId, userIds);
1075 }
1076
1077
1086 public void unsetPasswordPolicyUsers(long passwordPolicyId, long[] userIds)
1087 throws PortalException, SystemException {
1088
1089 PasswordPolicyPermissionUtil.check(
1090 getPermissionChecker(), passwordPolicyId,
1091 ActionKeys.ASSIGN_MEMBERS);
1092
1093 userLocalService.unsetPasswordPolicyUsers(passwordPolicyId, userIds);
1094 }
1095
1096
1105 public void unsetRoleUsers(long roleId, long[] userIds)
1106 throws PortalException, SystemException {
1107
1108 RolePermissionUtil.check(
1109 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
1110
1111 userLocalService.unsetRoleUsers(roleId, userIds);
1112 }
1113
1114
1123 public void unsetTeamUsers(long teamId, long[] userIds)
1124 throws PortalException, SystemException {
1125
1126 TeamPermissionUtil.check(
1127 getPermissionChecker(), teamId, ActionKeys.ASSIGN_MEMBERS);
1128
1129 userLocalService.unsetTeamUsers(teamId, userIds);
1130 }
1131
1132
1141 public void unsetUserGroupUsers(long userGroupId, long[] userIds)
1142 throws PortalException, SystemException {
1143
1144 UserGroupPermissionUtil.check(
1145 getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
1146
1147 userLocalService.unsetUserGroupUsers(userGroupId, userIds);
1148 }
1149
1150
1160 public User updateAgreedToTermsOfUse(
1161 long userId, boolean agreedToTermsOfUse)
1162 throws PortalException, SystemException {
1163
1164 UserPermissionUtil.check(
1165 getPermissionChecker(), userId, ActionKeys.UPDATE);
1166
1167 return userLocalService.updateAgreedToTermsOfUse(
1168 userId, agreedToTermsOfUse);
1169 }
1170
1171
1186 public User updateEmailAddress(
1187 long userId, String password, String emailAddress1,
1188 String emailAddress2, ServiceContext serviceContext)
1189 throws PortalException, SystemException {
1190
1191 UserPermissionUtil.check(
1192 getPermissionChecker(), userId, ActionKeys.UPDATE);
1193
1194 return userLocalService.updateEmailAddress(
1195 userId, password, emailAddress1, emailAddress2, serviceContext);
1196 }
1197
1198
1237 public User updateIncompleteUser(
1238 long companyId, boolean autoPassword, String password1,
1239 String password2, boolean autoScreenName, String screenName,
1240 String emailAddress, long facebookId, String openId, Locale locale,
1241 String firstName, String middleName, String lastName, int prefixId,
1242 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
1243 int birthdayYear, String jobTitle, boolean updateUserInformation,
1244 boolean sendEmail, ServiceContext serviceContext)
1245 throws PortalException, SystemException {
1246
1247 long creatorUserId = 0;
1248
1249 try {
1250 creatorUserId = getGuestOrUserId();
1251 }
1252 catch (PrincipalException pe) {
1253 }
1254
1255 checkAddUserPermission(
1256 creatorUserId, companyId, emailAddress, null, null, null, null,
1257 serviceContext);
1258
1259 return userLocalService.updateIncompleteUser(
1260 creatorUserId, companyId, autoPassword, password1, password2,
1261 autoScreenName, screenName, emailAddress, facebookId, openId,
1262 locale, firstName, middleName, lastName, prefixId, suffixId, male,
1263 birthdayMonth, birthdayDay, birthdayYear, jobTitle,
1264 updateUserInformation, sendEmail, serviceContext);
1265 }
1266
1267
1277 public User updateLockoutById(long userId, boolean lockout)
1278 throws PortalException, SystemException {
1279
1280 UserPermissionUtil.check(
1281 getPermissionChecker(), userId, ActionKeys.DELETE);
1282
1283 return userLocalService.updateLockoutById(userId, lockout);
1284 }
1285
1286
1296 public User updateOpenId(long userId, String openId)
1297 throws PortalException, SystemException {
1298
1299 UserPermissionUtil.check(
1300 getPermissionChecker(), userId, ActionKeys.UPDATE);
1301
1302 return userLocalService.updateOpenId(userId, openId);
1303 }
1304
1305
1317 public void updateOrganizations(
1318 long userId, long[] organizationIds, ServiceContext serviceContext)
1319 throws PortalException, SystemException {
1320
1321 UserPermissionUtil.check(
1322 getPermissionChecker(), userId, ActionKeys.UPDATE);
1323
1324 checkOrganizations(userId, organizationIds);
1325
1326 userLocalService.updateOrganizations(
1327 userId, organizationIds, serviceContext);
1328 }
1329
1330
1343 public User updatePassword(
1344 long userId, String password1, String password2,
1345 boolean passwordReset)
1346 throws PortalException, SystemException {
1347
1348 UserPermissionUtil.check(
1349 getPermissionChecker(), userId, ActionKeys.UPDATE);
1350
1351 return userLocalService.updatePassword(
1352 userId, password1, password2, passwordReset);
1353 }
1354
1355
1366 public User updatePortrait(long userId, byte[] bytes)
1367 throws PortalException, SystemException {
1368
1369 UserPermissionUtil.check(
1370 getPermissionChecker(), userId, ActionKeys.UPDATE);
1371
1372 return userLocalService.updatePortrait(userId, bytes);
1373 }
1374
1375
1387 public User updateReminderQuery(long userId, String question, String answer)
1388 throws PortalException, SystemException {
1389
1390 UserPermissionUtil.check(
1391 getPermissionChecker(), userId, ActionKeys.UPDATE);
1392
1393 return userLocalService.updateReminderQuery(userId, question, answer);
1394 }
1395
1396
1407 public User updateScreenName(long userId, String screenName)
1408 throws PortalException, SystemException {
1409
1410 UserPermissionUtil.check(
1411 getPermissionChecker(), userId, ActionKeys.UPDATE);
1412
1413 return userLocalService.updateScreenName(userId, screenName);
1414 }
1415
1416
1430 public User updateStatus(long userId, int status)
1431 throws PortalException, SystemException {
1432
1433 if ((getUserId() == userId) &&
1434 (status != WorkflowConstants.STATUS_APPROVED)) {
1435
1436 throw new RequiredUserException();
1437 }
1438
1439 UserPermissionUtil.check(
1440 getPermissionChecker(), userId, ActionKeys.DELETE);
1441
1442 return userLocalService.updateStatus(userId, status);
1443 }
1444
1445
1507 public User updateUser(
1508 long userId, String oldPassword, String newPassword1,
1509 String newPassword2, boolean passwordReset,
1510 String reminderQueryQuestion, String reminderQueryAnswer,
1511 String screenName, String emailAddress, long facebookId,
1512 String openId, String languageId, String timeZoneId,
1513 String greeting, String comments, String firstName,
1514 String middleName, String lastName, int prefixId, int suffixId,
1515 boolean male, int birthdayMonth, int birthdayDay, int birthdayYear,
1516 String smsSn, String aimSn, String facebookSn, String icqSn,
1517 String jabberSn, String msnSn, String mySpaceSn, String skypeSn,
1518 String twitterSn, String ymSn, String jobTitle, long[] groupIds,
1519 long[] organizationIds, long[] roleIds,
1520 List<UserGroupRole> userGroupRoles, long[] userGroupIds,
1521 List<Address> addresses, List<EmailAddress> emailAddresses,
1522 List<Phone> phones, List<Website> websites,
1523 List<AnnouncementsDelivery> announcementsDelivers,
1524 ServiceContext serviceContext)
1525 throws PortalException, SystemException {
1526
1527 UserPermissionUtil.check(
1528 getPermissionChecker(), userId, organizationIds, ActionKeys.UPDATE);
1529
1530 User user = userPersistence.findByPrimaryKey(userId);
1531
1532 if (addresses != null) {
1533 UsersAdminUtil.updateAddresses(
1534 Contact.class.getName(), user.getContactId(), addresses);
1535 }
1536
1537 if (emailAddresses != null) {
1538 UsersAdminUtil.updateEmailAddresses(
1539 Contact.class.getName(), user.getContactId(), emailAddresses);
1540 }
1541
1542 if (phones != null) {
1543 UsersAdminUtil.updatePhones(
1544 Contact.class.getName(), user.getContactId(), phones);
1545 }
1546
1547 if (websites != null) {
1548 UsersAdminUtil.updateWebsites(
1549 Contact.class.getName(), user.getContactId(), websites);
1550 }
1551
1552 if (announcementsDelivers != null) {
1553 updateAnnouncementsDeliveries(
1554 user.getUserId(), announcementsDelivers);
1555 }
1556
1557 long curUserId = getUserId();
1558
1559 if (curUserId == userId) {
1560 screenName = screenName.trim().toLowerCase();
1561
1562 if (!screenName.equalsIgnoreCase(user.getScreenName())) {
1563 validateScreenName(user, screenName);
1564 }
1565
1566 emailAddress = emailAddress.trim().toLowerCase();
1567
1568 if (!emailAddress.equalsIgnoreCase(user.getEmailAddress())) {
1569 validateEmailAddress(user, emailAddress);
1570 }
1571 }
1572
1573 if (groupIds != null) {
1574 groupIds = checkGroups(userId, groupIds);
1575 }
1576
1577 if (organizationIds != null) {
1578 organizationIds = checkOrganizations(userId, organizationIds);
1579 }
1580
1581 if (roleIds != null) {
1582 roleIds = checkRoles(userId, roleIds);
1583 }
1584
1585 if (userGroupRoles != null) {
1586 userGroupRoles = checkUserGroupRoles(userId, userGroupRoles);
1587 }
1588
1589 if (userGroupIds != null) {
1590 userGroupIds = checkUserGroupIds(userId, userGroupIds);
1591 }
1592
1593 return userLocalService.updateUser(
1594 userId, oldPassword, newPassword1, newPassword2, passwordReset,
1595 reminderQueryQuestion, reminderQueryAnswer, screenName,
1596 emailAddress, facebookId, openId, languageId, timeZoneId, greeting,
1597 comments, firstName, middleName, lastName, prefixId, suffixId, male,
1598 birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn, facebookSn,
1599 icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn, ymSn,
1600 jobTitle, groupIds, organizationIds, roleIds, userGroupRoles,
1601 userGroupIds, serviceContext);
1602 }
1603
1604
1661 public User updateUser(
1662 long userId, String oldPassword, String newPassword1,
1663 String newPassword2, boolean passwordReset,
1664 String reminderQueryQuestion, String reminderQueryAnswer,
1665 String screenName, String emailAddress, long facebookId,
1666 String openId, String languageId, String timeZoneId,
1667 String greeting, String comments, String firstName,
1668 String middleName, String lastName, int prefixId, int suffixId,
1669 boolean male, int birthdayMonth, int birthdayDay, int birthdayYear,
1670 String smsSn, String aimSn, String facebookSn, String icqSn,
1671 String jabberSn, String msnSn, String mySpaceSn, String skypeSn,
1672 String twitterSn, String ymSn, String jobTitle, long[] groupIds,
1673 long[] organizationIds, long[] roleIds,
1674 List<UserGroupRole> userGroupRoles, long[] userGroupIds,
1675 ServiceContext serviceContext)
1676 throws PortalException, SystemException {
1677
1678 return updateUser(
1679 userId, oldPassword, newPassword1, newPassword2, passwordReset,
1680 reminderQueryQuestion, reminderQueryAnswer, screenName,
1681 emailAddress, facebookId, openId, languageId, timeZoneId, greeting,
1682 comments, firstName, middleName, lastName, prefixId, suffixId, male,
1683 birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn, facebookSn,
1684 icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn, ymSn,
1685 jobTitle, groupIds, organizationIds, roleIds, userGroupRoles,
1686 userGroupIds, null, null, null, null, null, serviceContext);
1687 }
1688
1689 protected void checkAddUserPermission(
1690 long creatorUserId, long companyId, String emailAddress,
1691 long[] groupIds, long[] organizationIds, long[] roleIds,
1692 long[] userGroupIds, ServiceContext serviceContext)
1693 throws PortalException, SystemException {
1694
1695 Company company = companyPersistence.findByPrimaryKey(companyId);
1696
1697 if (groupIds != null) {
1698 checkGroups(CompanyConstants.SYSTEM, groupIds);
1699 }
1700
1701 if (organizationIds != null) {
1702 checkOrganizations(CompanyConstants.SYSTEM, organizationIds);
1703 }
1704
1705 if (roleIds != null) {
1706 checkRoles(CompanyConstants.SYSTEM, roleIds);
1707 }
1708
1709 if (userGroupIds != null) {
1710 checkUserGroupIds(CompanyConstants.SYSTEM, userGroupIds);
1711 }
1712
1713 boolean anonymousUser = ParamUtil.getBoolean(
1714 serviceContext, "anonymousUser");
1715
1716 long defaultUserId = userLocalService.getDefaultUserId(companyId);
1717
1718 if (((creatorUserId != 0) && (creatorUserId != defaultUserId)) ||
1719 (!company.isStrangers() && !anonymousUser)) {
1720
1721 if (!PortalPermissionUtil.contains(
1722 getPermissionChecker(), ActionKeys.ADD_USER) &&
1723 !OrganizationPermissionUtil.contains(
1724 getPermissionChecker(), organizationIds,
1725 ActionKeys.ASSIGN_MEMBERS)) {
1726
1727 throw new PrincipalException();
1728 }
1729 }
1730
1731 if ((creatorUserId == 0) || (creatorUserId == defaultUserId)) {
1732 if (!company.isStrangersWithMx() &&
1733 company.hasCompanyMx(emailAddress)) {
1734
1735 throw new ReservedUserEmailAddressException();
1736 }
1737 }
1738 }
1739
1740 protected long[] checkGroups(long userId, long[] groupIds)
1741 throws PortalException, SystemException {
1742
1743 long[] oldGroupIds = null;
1744
1745 PermissionChecker permissionChecker = getPermissionChecker();
1746
1747 if (userId != CompanyConstants.SYSTEM) {
1748
1749
1750
1751
1752
1753 List<Group> oldGroups = groupLocalService.getUserGroups(userId);
1754
1755 oldGroupIds = new long[oldGroups.size()];
1756
1757 for (int i = 0; i < oldGroups.size(); i++) {
1758 Group group = oldGroups.get(i);
1759
1760 if (!ArrayUtil.contains(groupIds, group.getGroupId()) &&
1761 !GroupPermissionUtil.contains(
1762 permissionChecker, group.getGroupId(),
1763 ActionKeys.ASSIGN_MEMBERS)) {
1764
1765 groupIds = ArrayUtil.append(groupIds, group.getGroupId());
1766 }
1767
1768 oldGroupIds[i] = group.getGroupId();
1769 }
1770 }
1771
1772 for (long groupId : groupIds) {
1773 if ((oldGroupIds == null) ||
1774 !ArrayUtil.contains(oldGroupIds, groupId)) {
1775
1776 GroupPermissionUtil.check(
1777 permissionChecker, groupId, ActionKeys.ASSIGN_MEMBERS);
1778 }
1779 }
1780
1781 return groupIds;
1782 }
1783
1784 protected long[] checkOrganizations(long userId, long[] organizationIds)
1785 throws PortalException, SystemException {
1786
1787 long[] oldOrganizationIds = null;
1788
1789 PermissionChecker permissionChecker = getPermissionChecker();
1790
1791 if (userId != CompanyConstants.SYSTEM) {
1792
1793
1794
1795
1796
1797 List<Organization> oldOrganizations =
1798 organizationLocalService.getUserOrganizations(userId);
1799
1800 oldOrganizationIds = new long[oldOrganizations.size()];
1801
1802 for (int i = 0; i < oldOrganizations.size(); i++) {
1803 Organization organization = oldOrganizations.get(i);
1804
1805 if (!ArrayUtil.contains(
1806 organizationIds, organization.getOrganizationId()) &&
1807 !OrganizationPermissionUtil.contains(
1808 permissionChecker, organization.getOrganizationId(),
1809 ActionKeys.ASSIGN_MEMBERS)) {
1810
1811 organizationIds = ArrayUtil.append(
1812 organizationIds, organization.getOrganizationId());
1813 }
1814
1815 oldOrganizationIds[i] = organization.getOrganizationId();
1816 }
1817 }
1818
1819 for (long organizationId : organizationIds) {
1820 if ((oldOrganizationIds == null) ||
1821 !ArrayUtil.contains(oldOrganizationIds, organizationId)) {
1822
1823 OrganizationPermissionUtil.check(
1824 permissionChecker, organizationId,
1825 ActionKeys.ASSIGN_MEMBERS);
1826 }
1827 }
1828
1829 return organizationIds;
1830 }
1831
1832 protected long[] checkRoles(long userId, long[] roleIds)
1833 throws PrincipalException, SystemException {
1834
1835 long[] oldRoleIds = null;
1836
1837 PermissionChecker permissionChecker = getPermissionChecker();
1838
1839 if (userId != CompanyConstants.SYSTEM) {
1840
1841
1842
1843
1844
1845 List<Role> oldRoles = roleLocalService.getUserRoles(userId);
1846
1847 oldRoleIds = new long[oldRoles.size()];
1848
1849 for (int i = 0; i < oldRoles.size(); i++) {
1850 Role role = oldRoles.get(i);
1851
1852 if (!ArrayUtil.contains(roleIds, role.getRoleId()) &&
1853 !RolePermissionUtil.contains(
1854 permissionChecker, role.getRoleId(),
1855 ActionKeys.ASSIGN_MEMBERS)) {
1856
1857 roleIds = ArrayUtil.append(roleIds, role.getRoleId());
1858 }
1859
1860 oldRoleIds[i] = role.getRoleId();
1861 }
1862 }
1863
1864 for (long roleId : roleIds) {
1865 if ((oldRoleIds == null) ||
1866 !ArrayUtil.contains(oldRoleIds, roleId)) {
1867
1868 RolePermissionUtil.check(
1869 permissionChecker, roleId, ActionKeys.ASSIGN_MEMBERS);
1870 }
1871 }
1872
1873 return roleIds;
1874 }
1875
1876 protected long[] checkUserGroupIds(long userId, long[] userGroupIds)
1877 throws PortalException, SystemException {
1878
1879 long[] oldUserGroupIds = null;
1880
1881 PermissionChecker permissionChecker = getPermissionChecker();
1882
1883 if (userId != CompanyConstants.SYSTEM) {
1884
1885
1886
1887
1888
1889 List<UserGroup> oldUserGroups =
1890 userGroupLocalService.getUserUserGroups(userId);
1891
1892 oldUserGroupIds = new long[oldUserGroups.size()];
1893
1894 for (int i = 0; i < oldUserGroups.size(); i++) {
1895 UserGroup userGroup = oldUserGroups.get(i);
1896
1897 if (!ArrayUtil.contains(
1898 userGroupIds, userGroup.getUserGroupId()) &&
1899 !UserGroupPermissionUtil.contains(
1900 permissionChecker, userGroup.getUserGroupId(),
1901 ActionKeys.ASSIGN_MEMBERS)) {
1902
1903 userGroupIds = ArrayUtil.append(
1904 userGroupIds, userGroup.getUserGroupId());
1905 }
1906
1907 oldUserGroupIds[i] = userGroup.getUserGroupId();
1908 }
1909 }
1910
1911 for (long userGroupId : userGroupIds) {
1912 if ((oldUserGroupIds == null) ||
1913 !ArrayUtil.contains(oldUserGroupIds, userGroupId)) {
1914
1915 UserGroupPermissionUtil.check(
1916 permissionChecker, userGroupId, ActionKeys.ASSIGN_MEMBERS);
1917 }
1918 }
1919
1920 return userGroupIds;
1921 }
1922
1923 protected List<UserGroupRole> checkUserGroupRoles(
1924 long userId, List<UserGroupRole> userGroupRoles)
1925 throws PortalException, SystemException {
1926
1927 List<UserGroupRole> oldUserGroupRoles = null;
1928
1929 PermissionChecker permissionChecker = getPermissionChecker();
1930
1931 if (userId != CompanyConstants.SYSTEM) {
1932
1933
1934
1935
1936
1937 oldUserGroupRoles = userGroupRoleLocalService.getUserGroupRoles(
1938 userId);
1939
1940 for (UserGroupRole oldUserGroupRole : oldUserGroupRoles) {
1941 if (!userGroupRoles.contains(oldUserGroupRole) &&
1942 !UserGroupRolePermissionUtil.contains(
1943 permissionChecker, oldUserGroupRole.getGroupId(),
1944 oldUserGroupRole.getRoleId())) {
1945
1946 userGroupRoles.add(oldUserGroupRole);
1947 }
1948 }
1949 }
1950
1951 for (UserGroupRole userGroupRole : userGroupRoles) {
1952 if ((oldUserGroupRoles == null) ||
1953 !oldUserGroupRoles.contains(userGroupRole)) {
1954
1955 UserGroupRolePermissionUtil.check(
1956 permissionChecker, userGroupRole.getGroupId(),
1957 userGroupRole.getRoleId());
1958 }
1959 }
1960
1961 return userGroupRoles;
1962 }
1963
1964 protected void updateAnnouncementsDeliveries(
1965 long userId, List<AnnouncementsDelivery> announcementsDeliveries)
1966 throws PortalException, SystemException {
1967
1968 for (AnnouncementsDelivery announcementsDelivery :
1969 announcementsDeliveries) {
1970
1971 announcementsDeliveryService.updateDelivery(
1972 userId, announcementsDelivery.getType(),
1973 announcementsDelivery.getEmail(),
1974 announcementsDelivery.getSms(),
1975 announcementsDelivery.getWebsite());
1976 }
1977 }
1978
1979 protected void validateEmailAddress(User user, String emailAddress)
1980 throws PortalException, SystemException {
1981
1982 PermissionChecker permissionChecker = getPermissionChecker();
1983
1984 if (!UsersAdminUtil.hasUpdateEmailAddress(permissionChecker, user)) {
1985 throw new UserEmailAddressException();
1986 }
1987
1988 if (!user.hasCompanyMx() && user.hasCompanyMx(emailAddress)) {
1989 Company company = companyPersistence.findByPrimaryKey(
1990 user.getCompanyId());
1991
1992 if (!company.isStrangersWithMx()) {
1993 throw new ReservedUserEmailAddressException();
1994 }
1995 }
1996 }
1997
1998 protected void validateOrganizationUsers(long[] userIds)
1999 throws PortalException, SystemException {
2000
2001 PermissionChecker permissionChecker = getPermissionChecker();
2002
2003 if (!PropsValues.ORGANIZATIONS_ASSIGNMENT_STRICT ||
2004 permissionChecker.isCompanyAdmin()) {
2005
2006 return;
2007 }
2008
2009 for (long userId : userIds) {
2010 boolean allowed = false;
2011
2012 List<Organization> organizations =
2013 organizationLocalService.getUserOrganizations(userId);
2014
2015 for (Organization organization : organizations) {
2016 if (OrganizationPermissionUtil.contains(
2017 permissionChecker, organization,
2018 ActionKeys.MANAGE_USERS)) {
2019
2020 allowed = true;
2021
2022 break;
2023 }
2024 }
2025
2026 if (!allowed) {
2027 throw new PrincipalException();
2028 }
2029 }
2030 }
2031
2032 protected void validateScreenName(User user, String screenName)
2033 throws PortalException, SystemException {
2034
2035 PermissionChecker permissionChecker = getPermissionChecker();
2036
2037 if (!UsersAdminUtil.hasUpdateScreenName(permissionChecker, user)) {
2038 throw new UserScreenNameException();
2039 }
2040 }
2041
2042 }