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
087 @Override
088 public void addGroupUsers(
089 long groupId, long[] userIds, ServiceContext serviceContext)
090 throws PortalException, SystemException {
091
092 try {
093 GroupPermissionUtil.check(
094 getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
095 }
096 catch (PrincipalException pe) {
097
098
099
100 boolean hasPermission = false;
101
102 if (userIds.length == 0) {
103 hasPermission = true;
104 }
105 else if (userIds.length == 1) {
106 User user = getUser();
107
108 if (user.getUserId() == userIds[0]) {
109 Group group = groupPersistence.findByPrimaryKey(groupId);
110
111 if (user.getCompanyId() == group.getCompanyId()) {
112 int type = group.getType();
113
114 if (type == GroupConstants.TYPE_SITE_OPEN) {
115 hasPermission = true;
116 }
117 }
118 }
119 }
120
121 if (!hasPermission) {
122 throw new PrincipalException();
123 }
124 }
125
126 userLocalService.addGroupUsers(groupId, userIds);
127 }
128
129
140 @Override
141 public void addOrganizationUsers(long organizationId, long[] userIds)
142 throws PortalException, SystemException {
143
144 OrganizationPermissionUtil.check(
145 getPermissionChecker(), organizationId, ActionKeys.ASSIGN_MEMBERS);
146
147 validateOrganizationUsers(userIds);
148
149 userLocalService.addOrganizationUsers(organizationId, userIds);
150 }
151
152
162 @Override
163 public void addPasswordPolicyUsers(long passwordPolicyId, long[] userIds)
164 throws PortalException, SystemException {
165
166 PasswordPolicyPermissionUtil.check(
167 getPermissionChecker(), passwordPolicyId,
168 ActionKeys.ASSIGN_MEMBERS);
169
170 userLocalService.addPasswordPolicyUsers(passwordPolicyId, userIds);
171 }
172
173
183 @Override
184 public void addRoleUsers(long roleId, long[] userIds)
185 throws PortalException, SystemException {
186
187 RolePermissionUtil.check(
188 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
189
190 userLocalService.addRoleUsers(roleId, userIds);
191 }
192
193
203 @Override
204 public void addTeamUsers(long teamId, long[] userIds)
205 throws PortalException, SystemException {
206
207 TeamPermissionUtil.check(
208 getPermissionChecker(), teamId, ActionKeys.ASSIGN_MEMBERS);
209
210 userLocalService.addTeamUsers(teamId, userIds);
211 }
212
213
262 @Override
263 public User addUser(
264 long companyId, boolean autoPassword, String password1,
265 String password2, boolean autoScreenName, String screenName,
266 String emailAddress, long facebookId, String openId, Locale locale,
267 String firstName, String middleName, String lastName, int prefixId,
268 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
269 int birthdayYear, String jobTitle, long[] groupIds,
270 long[] organizationIds, long[] roleIds, long[] userGroupIds,
271 boolean sendEmail, ServiceContext serviceContext)
272 throws PortalException, SystemException {
273
274 boolean workflowEnabled = WorkflowThreadLocal.isEnabled();
275
276 try {
277 WorkflowThreadLocal.setEnabled(false);
278
279 return addUserWithWorkflow(
280 companyId, autoPassword, password1, password2, autoScreenName,
281 screenName, emailAddress, facebookId, openId, locale, firstName,
282 middleName, lastName, prefixId, suffixId, male, birthdayMonth,
283 birthdayDay, birthdayYear, jobTitle, groupIds, organizationIds,
284 roleIds, userGroupIds, sendEmail, serviceContext);
285 }
286 finally {
287 WorkflowThreadLocal.setEnabled(workflowEnabled);
288 }
289 }
290
291
345 @Override
346 public User addUser(
347 long companyId, boolean autoPassword, String password1,
348 String password2, boolean autoScreenName, String screenName,
349 String emailAddress, long facebookId, String openId, Locale locale,
350 String firstName, String middleName, String lastName, int prefixId,
351 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
352 int birthdayYear, String jobTitle, long[] groupIds,
353 long[] organizationIds, long[] roleIds, long[] userGroupIds,
354 List<Address> addresses, List<EmailAddress> emailAddresses,
355 List<Phone> phones, List<Website> websites,
356 List<AnnouncementsDelivery> announcementsDelivers,
357 boolean sendEmail, ServiceContext serviceContext)
358 throws PortalException, SystemException {
359
360 boolean workflowEnabled = WorkflowThreadLocal.isEnabled();
361
362 try {
363 WorkflowThreadLocal.setEnabled(false);
364
365 return addUserWithWorkflow(
366 companyId, autoPassword, password1, password2, autoScreenName,
367 screenName, emailAddress, facebookId, openId, locale, firstName,
368 middleName, lastName, prefixId, suffixId, male, birthdayMonth,
369 birthdayDay, birthdayYear, jobTitle, groupIds, organizationIds,
370 roleIds, userGroupIds, addresses, emailAddresses, phones,
371 websites, announcementsDelivers, sendEmail, serviceContext);
372 }
373 finally {
374 WorkflowThreadLocal.setEnabled(workflowEnabled);
375 }
376 }
377
378
388 @Override
389 public void addUserGroupUsers(long userGroupId, long[] userIds)
390 throws PortalException, SystemException {
391
392 UserGroupPermissionUtil.check(
393 getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
394
395 userLocalService.addUserGroupUsers(userGroupId, userIds);
396 }
397
398
447 @Override
448 public User addUserWithWorkflow(
449 long companyId, boolean autoPassword, String password1,
450 String password2, boolean autoScreenName, String screenName,
451 String emailAddress, long facebookId, String openId, Locale locale,
452 String firstName, String middleName, String lastName, int prefixId,
453 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
454 int birthdayYear, String jobTitle, long[] groupIds,
455 long[] organizationIds, long[] roleIds, long[] userGroupIds,
456 boolean sendEmail, ServiceContext serviceContext)
457 throws PortalException, SystemException {
458
459 long creatorUserId = 0;
460
461 try {
462 creatorUserId = getGuestOrUserId();
463 }
464 catch (PrincipalException pe) {
465 }
466
467 checkAddUserPermission(
468 creatorUserId, companyId, emailAddress, groupIds, organizationIds,
469 roleIds, userGroupIds, serviceContext);
470
471 return userLocalService.addUserWithWorkflow(
472 creatorUserId, companyId, autoPassword, password1, password2,
473 autoScreenName, screenName, emailAddress, facebookId, openId,
474 locale, firstName, middleName, lastName, prefixId, suffixId, male,
475 birthdayMonth, birthdayDay, birthdayYear, jobTitle, groupIds,
476 organizationIds, roleIds, userGroupIds, sendEmail, serviceContext);
477 }
478
479
533 @Override
534 public User addUserWithWorkflow(
535 long companyId, boolean autoPassword, String password1,
536 String password2, boolean autoScreenName, String screenName,
537 String emailAddress, long facebookId, String openId, Locale locale,
538 String firstName, String middleName, String lastName, int prefixId,
539 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
540 int birthdayYear, String jobTitle, long[] groupIds,
541 long[] organizationIds, long[] roleIds, long[] userGroupIds,
542 List<Address> addresses, List<EmailAddress> emailAddresses,
543 List<Phone> phones, List<Website> websites,
544 List<AnnouncementsDelivery> announcementsDelivers,
545 boolean sendEmail, ServiceContext serviceContext)
546 throws PortalException, SystemException {
547
548 boolean indexingEnabled = serviceContext.isIndexingEnabled();
549
550 serviceContext.setIndexingEnabled(false);
551
552 try {
553 User user = addUserWithWorkflow(
554 companyId, autoPassword, password1, password2, autoScreenName,
555 screenName, emailAddress, facebookId, openId, locale, firstName,
556 middleName, lastName, prefixId, suffixId, male, birthdayMonth,
557 birthdayDay, birthdayYear, jobTitle, groupIds, organizationIds,
558 roleIds, userGroupIds, sendEmail, serviceContext);
559
560 UsersAdminUtil.updateAddresses(
561 Contact.class.getName(), user.getContactId(), addresses);
562
563 UsersAdminUtil.updateEmailAddresses(
564 Contact.class.getName(), user.getContactId(), emailAddresses);
565
566 UsersAdminUtil.updatePhones(
567 Contact.class.getName(), user.getContactId(), phones);
568
569 UsersAdminUtil.updateWebsites(
570 Contact.class.getName(), user.getContactId(), websites);
571
572 updateAnnouncementsDeliveries(
573 user.getUserId(), announcementsDelivers);
574
575 if (indexingEnabled) {
576 Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
577 User.class);
578
579 indexer.reindex(user);
580 }
581
582 return user;
583 }
584 finally {
585 serviceContext.setIndexingEnabled(indexingEnabled);
586 }
587 }
588
589
598 @Override
599 public void deletePortrait(long userId)
600 throws PortalException, SystemException {
601
602 UserPermissionUtil.check(
603 getPermissionChecker(), userId, ActionKeys.UPDATE);
604
605 userLocalService.deletePortrait(userId);
606 }
607
608
618 @Override
619 public void deleteRoleUser(long roleId, long userId)
620 throws PortalException, SystemException {
621
622 RolePermissionUtil.check(
623 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
624
625 userLocalService.deleteRoleUser(roleId, userId);
626 }
627
628
636 @Override
637 public void deleteUser(long userId)
638 throws PortalException, SystemException {
639
640 if (getUserId() == userId) {
641 throw new RequiredUserException();
642 }
643
644 UserPermissionUtil.check(
645 getPermissionChecker(), userId, ActionKeys.DELETE);
646
647 userLocalService.deleteUser(userId);
648 }
649
650 @Override
651 public List<User> getCompanyUsers(long companyId, int start, int end)
652 throws PortalException, SystemException {
653
654 PermissionChecker permissionChecker = getPermissionChecker();
655
656 if (!permissionChecker.isCompanyAdmin(companyId)) {
657 throw new PrincipalException();
658 }
659
660 return userPersistence.findByCompanyId(companyId, start, end);
661 }
662
663 @Override
664 public int getCompanyUsersCount(long companyId)
665 throws PortalException, SystemException {
666
667 PermissionChecker permissionChecker = getPermissionChecker();
668
669 if (!permissionChecker.isCompanyAdmin(companyId)) {
670 throw new PrincipalException();
671 }
672
673 return userPersistence.countByCompanyId(companyId);
674 }
675
676
685 @Override
686 public long getDefaultUserId(long companyId)
687 throws PortalException, SystemException {
688
689 return userLocalService.getDefaultUserId(companyId);
690 }
691
692
701 @Override
702 public long[] getGroupUserIds(long groupId)
703 throws PortalException, SystemException {
704
705 GroupPermissionUtil.check(
706 getPermissionChecker(), groupId, ActionKeys.VIEW_MEMBERS);
707
708 return userLocalService.getGroupUserIds(groupId);
709 }
710
711
720 @Override
721 public List<User> getGroupUsers(long groupId)
722 throws PortalException, SystemException {
723
724 GroupPermissionUtil.check(
725 getPermissionChecker(), groupId, ActionKeys.VIEW_MEMBERS);
726
727 return userLocalService.getGroupUsers(groupId);
728 }
729
730
739 @Override
740 public long[] getOrganizationUserIds(long organizationId)
741 throws PortalException, SystemException {
742
743 OrganizationPermissionUtil.check(
744 getPermissionChecker(), organizationId, ActionKeys.VIEW_MEMBERS);
745
746 return userLocalService.getOrganizationUserIds(organizationId);
747 }
748
749
758 @Override
759 public List<User> getOrganizationUsers(long organizationId)
760 throws PortalException, SystemException {
761
762 OrganizationPermissionUtil.check(
763 getPermissionChecker(), organizationId, ActionKeys.VIEW_MEMBERS);
764
765 return userLocalService.getOrganizationUsers(organizationId);
766 }
767
768
777 @Override
778 public long[] getRoleUserIds(long roleId)
779 throws PortalException, SystemException {
780
781 RolePermissionUtil.check(
782 getPermissionChecker(), roleId, ActionKeys.VIEW);
783
784 return userLocalService.getRoleUserIds(roleId);
785 }
786
787
798 @Override
799 public User getUserByEmailAddress(long companyId, String emailAddress)
800 throws PortalException, SystemException {
801
802 User user = userLocalService.getUserByEmailAddress(
803 companyId, emailAddress);
804
805 UserPermissionUtil.check(
806 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
807
808 return user;
809 }
810
811
820 @Override
821 public User getUserById(long userId)
822 throws PortalException, SystemException {
823
824 User user = userPersistence.findByPrimaryKey(userId);
825
826 UserPermissionUtil.check(
827 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
828
829 return user;
830 }
831
832
842 @Override
843 public User getUserByScreenName(long companyId, String screenName)
844 throws PortalException, SystemException {
845
846 User user = userLocalService.getUserByScreenName(companyId, screenName);
847
848 UserPermissionUtil.check(
849 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
850
851 return user;
852 }
853
854 @Override
855 public List<User> getUserGroupUsers(long userGroupId)
856 throws PortalException, SystemException {
857
858 UserGroupPermissionUtil.check(
859 getPermissionChecker(), userGroupId, ActionKeys.VIEW_MEMBERS);
860
861 return userGroupPersistence.getUsers(userGroupId);
862 }
863
864
874 @Override
875 public long getUserIdByEmailAddress(long companyId, String emailAddress)
876 throws PortalException, SystemException {
877
878 User user = getUserByEmailAddress(companyId, emailAddress);
879
880 UserPermissionUtil.check(
881 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
882
883 return user.getUserId();
884 }
885
886
895 @Override
896 public long getUserIdByScreenName(long companyId, String screenName)
897 throws PortalException, SystemException {
898
899 User user = getUserByScreenName(companyId, screenName);
900
901 UserPermissionUtil.check(
902 getPermissionChecker(), user.getUserId(), ActionKeys.VIEW);
903
904 return user.getUserId();
905 }
906
907
918 @Override
919 public boolean hasGroupUser(long groupId, long userId)
920 throws PortalException, SystemException {
921
922 try {
923 UserPermissionUtil.check(
924 getPermissionChecker(), userId, ActionKeys.VIEW);
925 }
926 catch (PrincipalException pe) {
927 GroupPermissionUtil.check(
928 getPermissionChecker(), groupId, ActionKeys.VIEW_MEMBERS);
929 }
930
931 return userLocalService.hasGroupUser(groupId, userId);
932 }
933
934
945 @Override
946 public boolean hasRoleUser(long roleId, long userId)
947 throws PortalException, SystemException {
948
949 try {
950 UserPermissionUtil.check(
951 getPermissionChecker(), userId, ActionKeys.VIEW);
952 }
953 catch (PrincipalException pe) {
954 RolePermissionUtil.check(
955 getPermissionChecker(), roleId, ActionKeys.VIEW_MEMBERS);
956 }
957
958 return userLocalService.hasRoleUser(roleId, userId);
959 }
960
961
976 @Override
977 public boolean hasRoleUser(
978 long companyId, String name, long userId, boolean inherited)
979 throws PortalException, SystemException {
980
981 try {
982 UserPermissionUtil.check(
983 getPermissionChecker(), userId, ActionKeys.VIEW);
984 }
985 catch (PrincipalException pe) {
986 Role role = roleLocalService.getRole(companyId, name);
987
988 RolePermissionUtil.check(
989 getPermissionChecker(), role.getRoleId(),
990 ActionKeys.VIEW_MEMBERS);
991 }
992
993 return userLocalService.hasRoleUser(companyId, name, userId, inherited);
994 }
995
996
1006 @Override
1007 public void setRoleUsers(long roleId, long[] userIds)
1008 throws PortalException, SystemException {
1009
1010 RolePermissionUtil.check(
1011 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
1012
1013 userLocalService.setRoleUsers(roleId, userIds);
1014 }
1015
1016
1026 @Override
1027 public void setUserGroupUsers(long userGroupId, long[] userIds)
1028 throws PortalException, SystemException {
1029
1030 UserGroupPermissionUtil.check(
1031 getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
1032
1033 userLocalService.setUserGroupUsers(userGroupId, userIds);
1034 }
1035
1036
1045 @Override
1046 public void unsetGroupTeamsUsers(long groupId, long[] userIds)
1047 throws PortalException, SystemException {
1048
1049 UserGroupPermissionUtil.check(
1050 getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
1051
1052 userLocalService.unsetGroupTeamsUsers(groupId, userIds);
1053 }
1054
1055
1066 @Override
1067 public void unsetGroupUsers(
1068 long groupId, long[] userIds, ServiceContext serviceContext)
1069 throws PortalException, SystemException {
1070
1071 try {
1072 GroupPermissionUtil.check(
1073 getPermissionChecker(), groupId, ActionKeys.ASSIGN_MEMBERS);
1074 }
1075 catch (PrincipalException pe) {
1076
1077
1078
1079 boolean hasPermission = false;
1080
1081 if (userIds.length == 0) {
1082 hasPermission = true;
1083 }
1084 else if (userIds.length == 1) {
1085 User user = getUser();
1086
1087 if (user.getUserId() == userIds[0]) {
1088 Group group = groupPersistence.findByPrimaryKey(groupId);
1089
1090 if (user.getCompanyId() == group.getCompanyId()) {
1091 int type = group.getType();
1092
1093 if ((type == GroupConstants.TYPE_SITE_OPEN) ||
1094 (type == GroupConstants.TYPE_SITE_RESTRICTED)) {
1095
1096 hasPermission = true;
1097 }
1098 }
1099 }
1100 }
1101
1102 if (!hasPermission) {
1103 throw new PrincipalException();
1104 }
1105 }
1106
1107 userLocalService.unsetGroupUsers(groupId, userIds, serviceContext);
1108 }
1109
1110
1119 @Override
1120 public void unsetOrganizationUsers(long organizationId, long[] userIds)
1121 throws PortalException, SystemException {
1122
1123 OrganizationPermissionUtil.check(
1124 getPermissionChecker(), organizationId, ActionKeys.ASSIGN_MEMBERS);
1125
1126 userLocalService.unsetOrganizationUsers(organizationId, userIds);
1127 }
1128
1129
1138 @Override
1139 public void unsetPasswordPolicyUsers(long passwordPolicyId, long[] userIds)
1140 throws PortalException, SystemException {
1141
1142 PasswordPolicyPermissionUtil.check(
1143 getPermissionChecker(), passwordPolicyId,
1144 ActionKeys.ASSIGN_MEMBERS);
1145
1146 userLocalService.unsetPasswordPolicyUsers(passwordPolicyId, userIds);
1147 }
1148
1149
1158 @Override
1159 public void unsetRoleUsers(long roleId, long[] userIds)
1160 throws PortalException, SystemException {
1161
1162 RolePermissionUtil.check(
1163 getPermissionChecker(), roleId, ActionKeys.ASSIGN_MEMBERS);
1164
1165 userLocalService.unsetRoleUsers(roleId, userIds);
1166 }
1167
1168
1177 @Override
1178 public void unsetTeamUsers(long teamId, long[] userIds)
1179 throws PortalException, SystemException {
1180
1181 TeamPermissionUtil.check(
1182 getPermissionChecker(), teamId, ActionKeys.ASSIGN_MEMBERS);
1183
1184 userLocalService.unsetTeamUsers(teamId, userIds);
1185 }
1186
1187
1196 @Override
1197 public void unsetUserGroupUsers(long userGroupId, long[] userIds)
1198 throws PortalException, SystemException {
1199
1200 UserGroupPermissionUtil.check(
1201 getPermissionChecker(), userGroupId, ActionKeys.ASSIGN_MEMBERS);
1202
1203 userLocalService.unsetUserGroupUsers(userGroupId, userIds);
1204 }
1205
1206
1216 @Override
1217 public User updateAgreedToTermsOfUse(
1218 long userId, boolean agreedToTermsOfUse)
1219 throws PortalException, SystemException {
1220
1221 UserPermissionUtil.check(
1222 getPermissionChecker(), userId, ActionKeys.UPDATE);
1223
1224 return userLocalService.updateAgreedToTermsOfUse(
1225 userId, agreedToTermsOfUse);
1226 }
1227
1228
1243 @Override
1244 public User updateEmailAddress(
1245 long userId, String password, String emailAddress1,
1246 String emailAddress2, ServiceContext serviceContext)
1247 throws PortalException, SystemException {
1248
1249 UserPermissionUtil.check(
1250 getPermissionChecker(), userId, ActionKeys.UPDATE);
1251
1252 User user = userPersistence.findByPrimaryKey(userId);
1253
1254 validateEmailAddress(user, emailAddress2);
1255
1256 return userLocalService.updateEmailAddress(
1257 userId, password, emailAddress1, emailAddress2, serviceContext);
1258 }
1259
1260
1299 @Override
1300 public User updateIncompleteUser(
1301 long companyId, boolean autoPassword, String password1,
1302 String password2, boolean autoScreenName, String screenName,
1303 String emailAddress, long facebookId, String openId, Locale locale,
1304 String firstName, String middleName, String lastName, int prefixId,
1305 int suffixId, boolean male, int birthdayMonth, int birthdayDay,
1306 int birthdayYear, String jobTitle, boolean updateUserInformation,
1307 boolean sendEmail, ServiceContext serviceContext)
1308 throws PortalException, SystemException {
1309
1310 long creatorUserId = 0;
1311
1312 try {
1313 creatorUserId = getGuestOrUserId();
1314 }
1315 catch (PrincipalException pe) {
1316 }
1317
1318 checkAddUserPermission(
1319 creatorUserId, companyId, emailAddress, null, null, null, null,
1320 serviceContext);
1321
1322 return userLocalService.updateIncompleteUser(
1323 creatorUserId, companyId, autoPassword, password1, password2,
1324 autoScreenName, screenName, emailAddress, facebookId, openId,
1325 locale, firstName, middleName, lastName, prefixId, suffixId, male,
1326 birthdayMonth, birthdayDay, birthdayYear, jobTitle,
1327 updateUserInformation, sendEmail, serviceContext);
1328 }
1329
1330
1340 @Override
1341 public User updateLockoutById(long userId, boolean lockout)
1342 throws PortalException, SystemException {
1343
1344 UserPermissionUtil.check(
1345 getPermissionChecker(), userId, ActionKeys.DELETE);
1346
1347 return userLocalService.updateLockoutById(userId, lockout);
1348 }
1349
1350
1360 @Override
1361 public User updateOpenId(long userId, String openId)
1362 throws PortalException, SystemException {
1363
1364 UserPermissionUtil.check(
1365 getPermissionChecker(), userId, ActionKeys.UPDATE);
1366
1367 return userLocalService.updateOpenId(userId, openId);
1368 }
1369
1370
1382 @Override
1383 public void updateOrganizations(
1384 long userId, long[] organizationIds, ServiceContext serviceContext)
1385 throws PortalException, SystemException {
1386
1387 UserPermissionUtil.check(
1388 getPermissionChecker(), userId, ActionKeys.UPDATE);
1389
1390 checkOrganizations(userId, organizationIds);
1391
1392 userLocalService.updateOrganizations(
1393 userId, organizationIds, serviceContext);
1394 }
1395
1396
1409 @Override
1410 public User updatePassword(
1411 long userId, String password1, String password2,
1412 boolean passwordReset)
1413 throws PortalException, SystemException {
1414
1415 UserPermissionUtil.check(
1416 getPermissionChecker(), userId, ActionKeys.UPDATE);
1417
1418 return userLocalService.updatePassword(
1419 userId, password1, password2, passwordReset);
1420 }
1421
1422
1433 @Override
1434 public User updatePortrait(long userId, byte[] bytes)
1435 throws PortalException, SystemException {
1436
1437 UserPermissionUtil.check(
1438 getPermissionChecker(), userId, ActionKeys.UPDATE);
1439
1440 return userLocalService.updatePortrait(userId, bytes);
1441 }
1442
1443
1455 @Override
1456 public User updateReminderQuery(long userId, String question, String answer)
1457 throws PortalException, SystemException {
1458
1459 UserPermissionUtil.check(
1460 getPermissionChecker(), userId, ActionKeys.UPDATE);
1461
1462 return userLocalService.updateReminderQuery(userId, question, answer);
1463 }
1464
1465
1476 @Override
1477 public User updateScreenName(long userId, String screenName)
1478 throws PortalException, SystemException {
1479
1480 UserPermissionUtil.check(
1481 getPermissionChecker(), userId, ActionKeys.UPDATE);
1482
1483 return userLocalService.updateScreenName(userId, screenName);
1484 }
1485
1486
1499 @Override
1500 public User updateStatus(long userId, int status)
1501 throws PortalException, SystemException {
1502
1503 if ((getUserId() == userId) &&
1504 (status != WorkflowConstants.STATUS_APPROVED)) {
1505
1506 throw new RequiredUserException();
1507 }
1508
1509 UserPermissionUtil.check(
1510 getPermissionChecker(), userId, ActionKeys.DELETE);
1511
1512 return userLocalService.updateStatus(userId, status);
1513 }
1514
1515
1577 @Override
1578 public User updateUser(
1579 long userId, String oldPassword, String newPassword1,
1580 String newPassword2, boolean passwordReset,
1581 String reminderQueryQuestion, String reminderQueryAnswer,
1582 String screenName, String emailAddress, long facebookId,
1583 String openId, String languageId, String timeZoneId,
1584 String greeting, String comments, String firstName,
1585 String middleName, String lastName, int prefixId, int suffixId,
1586 boolean male, int birthdayMonth, int birthdayDay, int birthdayYear,
1587 String smsSn, String aimSn, String facebookSn, String icqSn,
1588 String jabberSn, String msnSn, String mySpaceSn, String skypeSn,
1589 String twitterSn, String ymSn, String jobTitle, long[] groupIds,
1590 long[] organizationIds, long[] roleIds,
1591 List<UserGroupRole> userGroupRoles, long[] userGroupIds,
1592 List<Address> addresses, List<EmailAddress> emailAddresses,
1593 List<Phone> phones, List<Website> websites,
1594 List<AnnouncementsDelivery> announcementsDelivers,
1595 ServiceContext serviceContext)
1596 throws PortalException, SystemException {
1597
1598 UserPermissionUtil.check(
1599 getPermissionChecker(), userId, organizationIds, ActionKeys.UPDATE);
1600
1601 User user = userPersistence.findByPrimaryKey(userId);
1602
1603 if (addresses != null) {
1604 UsersAdminUtil.updateAddresses(
1605 Contact.class.getName(), user.getContactId(), addresses);
1606 }
1607
1608 if (emailAddresses != null) {
1609 UsersAdminUtil.updateEmailAddresses(
1610 Contact.class.getName(), user.getContactId(), emailAddresses);
1611 }
1612
1613 if (phones != null) {
1614 UsersAdminUtil.updatePhones(
1615 Contact.class.getName(), user.getContactId(), phones);
1616 }
1617
1618 if (websites != null) {
1619 UsersAdminUtil.updateWebsites(
1620 Contact.class.getName(), user.getContactId(), websites);
1621 }
1622
1623 if (announcementsDelivers != null) {
1624 updateAnnouncementsDeliveries(
1625 user.getUserId(), announcementsDelivers);
1626 }
1627
1628 long curUserId = getUserId();
1629
1630 if (curUserId == userId) {
1631 screenName = screenName.trim().toLowerCase();
1632
1633 if (!screenName.equalsIgnoreCase(user.getScreenName())) {
1634 validateScreenName(user, screenName);
1635 }
1636
1637 emailAddress = emailAddress.trim().toLowerCase();
1638
1639 if (!emailAddress.equalsIgnoreCase(user.getEmailAddress())) {
1640 validateEmailAddress(user, emailAddress);
1641 }
1642 }
1643
1644 if (groupIds != null) {
1645 groupIds = checkGroups(userId, groupIds);
1646 }
1647
1648 if (organizationIds != null) {
1649 organizationIds = checkOrganizations(userId, organizationIds);
1650 }
1651
1652 if (roleIds != null) {
1653 roleIds = checkRoles(userId, roleIds);
1654 }
1655
1656 if (userGroupRoles != null) {
1657 userGroupRoles = checkUserGroupRoles(userId, userGroupRoles);
1658 }
1659
1660 if (userGroupIds != null) {
1661 userGroupIds = checkUserGroupIds(userId, userGroupIds);
1662 }
1663
1664 return userLocalService.updateUser(
1665 userId, oldPassword, newPassword1, newPassword2, passwordReset,
1666 reminderQueryQuestion, reminderQueryAnswer, screenName,
1667 emailAddress, facebookId, openId, languageId, timeZoneId, greeting,
1668 comments, firstName, middleName, lastName, prefixId, suffixId, male,
1669 birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn, facebookSn,
1670 icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn, ymSn,
1671 jobTitle, groupIds, organizationIds, roleIds, userGroupRoles,
1672 userGroupIds, serviceContext);
1673 }
1674
1675
1732 @Override
1733 public User updateUser(
1734 long userId, String oldPassword, String newPassword1,
1735 String newPassword2, boolean passwordReset,
1736 String reminderQueryQuestion, String reminderQueryAnswer,
1737 String screenName, String emailAddress, long facebookId,
1738 String openId, String languageId, String timeZoneId,
1739 String greeting, String comments, String firstName,
1740 String middleName, String lastName, int prefixId, int suffixId,
1741 boolean male, int birthdayMonth, int birthdayDay, int birthdayYear,
1742 String smsSn, String aimSn, String facebookSn, String icqSn,
1743 String jabberSn, String msnSn, String mySpaceSn, String skypeSn,
1744 String twitterSn, String ymSn, String jobTitle, long[] groupIds,
1745 long[] organizationIds, long[] roleIds,
1746 List<UserGroupRole> userGroupRoles, long[] userGroupIds,
1747 ServiceContext serviceContext)
1748 throws PortalException, SystemException {
1749
1750 return updateUser(
1751 userId, oldPassword, newPassword1, newPassword2, passwordReset,
1752 reminderQueryQuestion, reminderQueryAnswer, screenName,
1753 emailAddress, facebookId, openId, languageId, timeZoneId, greeting,
1754 comments, firstName, middleName, lastName, prefixId, suffixId, male,
1755 birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn, facebookSn,
1756 icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn, ymSn,
1757 jobTitle, groupIds, organizationIds, roleIds, userGroupRoles,
1758 userGroupIds, null, null, null, null, null, serviceContext);
1759 }
1760
1761 protected void checkAddUserPermission(
1762 long creatorUserId, long companyId, String emailAddress,
1763 long[] groupIds, long[] organizationIds, long[] roleIds,
1764 long[] userGroupIds, ServiceContext serviceContext)
1765 throws PortalException, SystemException {
1766
1767 Company company = companyPersistence.findByPrimaryKey(companyId);
1768
1769 if (groupIds != null) {
1770 checkGroups(CompanyConstants.SYSTEM, groupIds);
1771 }
1772
1773 if (organizationIds != null) {
1774 checkOrganizations(CompanyConstants.SYSTEM, organizationIds);
1775 }
1776
1777 if (roleIds != null) {
1778 checkRoles(CompanyConstants.SYSTEM, roleIds);
1779 }
1780
1781 if (userGroupIds != null) {
1782 checkUserGroupIds(CompanyConstants.SYSTEM, userGroupIds);
1783 }
1784
1785 boolean anonymousUser = ParamUtil.getBoolean(
1786 serviceContext, "anonymousUser");
1787
1788 if (((creatorUserId != 0) &&
1789 (creatorUserId != getDefaultUserId(companyId))) ||
1790 (!company.isStrangers() && !anonymousUser)) {
1791
1792 if (!PortalPermissionUtil.contains(
1793 getPermissionChecker(), ActionKeys.ADD_USER) &&
1794 !OrganizationPermissionUtil.contains(
1795 getPermissionChecker(), organizationIds,
1796 ActionKeys.ASSIGN_MEMBERS)) {
1797
1798 throw new PrincipalException();
1799 }
1800 }
1801
1802 if ((creatorUserId == 0) ||
1803 (creatorUserId == getDefaultUserId(companyId))) {
1804
1805 if (!company.isStrangersWithMx() &&
1806 company.hasCompanyMx(emailAddress)) {
1807
1808 throw new ReservedUserEmailAddressException();
1809 }
1810 }
1811 }
1812
1813 protected long[] checkGroups(long userId, long[] groupIds)
1814 throws PortalException, SystemException {
1815
1816 long[] oldGroupIds = null;
1817
1818 PermissionChecker permissionChecker = getPermissionChecker();
1819
1820 if (userId != CompanyConstants.SYSTEM) {
1821
1822
1823
1824
1825
1826 List<Group> oldGroups = groupLocalService.getUserGroups(userId);
1827
1828 oldGroupIds = new long[oldGroups.size()];
1829
1830 for (int i = 0; i < oldGroups.size(); i++) {
1831 Group group = oldGroups.get(i);
1832
1833 if (!ArrayUtil.contains(groupIds, group.getGroupId()) &&
1834 !GroupPermissionUtil.contains(
1835 permissionChecker, group.getGroupId(),
1836 ActionKeys.ASSIGN_MEMBERS)) {
1837
1838 groupIds = ArrayUtil.append(groupIds, group.getGroupId());
1839 }
1840
1841 oldGroupIds[i] = group.getGroupId();
1842 }
1843 }
1844
1845 for (long groupId : groupIds) {
1846 if ((oldGroupIds == null) ||
1847 !ArrayUtil.contains(oldGroupIds, groupId)) {
1848
1849 GroupPermissionUtil.check(
1850 permissionChecker, groupId, ActionKeys.ASSIGN_MEMBERS);
1851 }
1852 }
1853
1854 return groupIds;
1855 }
1856
1857 protected long[] checkOrganizations(long userId, long[] organizationIds)
1858 throws PortalException, SystemException {
1859
1860 long[] oldOrganizationIds = null;
1861
1862 PermissionChecker permissionChecker = getPermissionChecker();
1863
1864 if (userId != CompanyConstants.SYSTEM) {
1865
1866
1867
1868
1869
1870 List<Organization> oldOrganizations =
1871 organizationLocalService.getUserOrganizations(userId);
1872
1873 oldOrganizationIds = new long[oldOrganizations.size()];
1874
1875 for (int i = 0; i < oldOrganizations.size(); i++) {
1876 Organization organization = oldOrganizations.get(i);
1877
1878 if (!ArrayUtil.contains(
1879 organizationIds, organization.getOrganizationId()) &&
1880 !OrganizationPermissionUtil.contains(
1881 permissionChecker, organization.getOrganizationId(),
1882 ActionKeys.ASSIGN_MEMBERS)) {
1883
1884 organizationIds = ArrayUtil.append(
1885 organizationIds, organization.getOrganizationId());
1886 }
1887
1888 oldOrganizationIds[i] = organization.getOrganizationId();
1889 }
1890 }
1891
1892 for (long organizationId : organizationIds) {
1893 if ((oldOrganizationIds == null) ||
1894 !ArrayUtil.contains(oldOrganizationIds, organizationId)) {
1895
1896 OrganizationPermissionUtil.check(
1897 permissionChecker, organizationId,
1898 ActionKeys.ASSIGN_MEMBERS);
1899 }
1900 }
1901
1902 return organizationIds;
1903 }
1904
1905 protected long[] checkRoles(long userId, long[] roleIds)
1906 throws PrincipalException, SystemException {
1907
1908 long[] oldRoleIds = null;
1909
1910 PermissionChecker permissionChecker = getPermissionChecker();
1911
1912 if (userId != CompanyConstants.SYSTEM) {
1913
1914
1915
1916
1917
1918 List<Role> oldRoles = roleLocalService.getUserRoles(userId);
1919
1920 oldRoleIds = new long[oldRoles.size()];
1921
1922 for (int i = 0; i < oldRoles.size(); i++) {
1923 Role role = oldRoles.get(i);
1924
1925 if (!ArrayUtil.contains(roleIds, role.getRoleId()) &&
1926 !RolePermissionUtil.contains(
1927 permissionChecker, role.getRoleId(),
1928 ActionKeys.ASSIGN_MEMBERS)) {
1929
1930 roleIds = ArrayUtil.append(roleIds, role.getRoleId());
1931 }
1932
1933 oldRoleIds[i] = role.getRoleId();
1934 }
1935 }
1936
1937 for (long roleId : roleIds) {
1938 if ((oldRoleIds == null) ||
1939 !ArrayUtil.contains(oldRoleIds, roleId)) {
1940
1941 RolePermissionUtil.check(
1942 permissionChecker, roleId, ActionKeys.ASSIGN_MEMBERS);
1943 }
1944 }
1945
1946 return roleIds;
1947 }
1948
1949 protected long[] checkUserGroupIds(long userId, long[] userGroupIds)
1950 throws PortalException, SystemException {
1951
1952 long[] oldUserGroupIds = null;
1953
1954 PermissionChecker permissionChecker = getPermissionChecker();
1955
1956 if (userId != CompanyConstants.SYSTEM) {
1957
1958
1959
1960
1961
1962 List<UserGroup> oldUserGroups =
1963 userGroupLocalService.getUserUserGroups(userId);
1964
1965 oldUserGroupIds = new long[oldUserGroups.size()];
1966
1967 for (int i = 0; i < oldUserGroups.size(); i++) {
1968 UserGroup userGroup = oldUserGroups.get(i);
1969
1970 if (!ArrayUtil.contains(
1971 userGroupIds, userGroup.getUserGroupId()) &&
1972 !UserGroupPermissionUtil.contains(
1973 permissionChecker, userGroup.getUserGroupId(),
1974 ActionKeys.ASSIGN_MEMBERS)) {
1975
1976 userGroupIds = ArrayUtil.append(
1977 userGroupIds, userGroup.getUserGroupId());
1978 }
1979
1980 oldUserGroupIds[i] = userGroup.getUserGroupId();
1981 }
1982 }
1983
1984 for (long userGroupId : userGroupIds) {
1985 if ((oldUserGroupIds == null) ||
1986 !ArrayUtil.contains(oldUserGroupIds, userGroupId)) {
1987
1988 UserGroupPermissionUtil.check(
1989 permissionChecker, userGroupId, ActionKeys.ASSIGN_MEMBERS);
1990 }
1991 }
1992
1993 return userGroupIds;
1994 }
1995
1996 protected List<UserGroupRole> checkUserGroupRoles(
1997 long userId, List<UserGroupRole> userGroupRoles)
1998 throws PortalException, SystemException {
1999
2000 List<UserGroupRole> oldUserGroupRoles = null;
2001
2002 PermissionChecker permissionChecker = getPermissionChecker();
2003
2004 if (userId != CompanyConstants.SYSTEM) {
2005
2006
2007
2008
2009
2010 oldUserGroupRoles = userGroupRoleLocalService.getUserGroupRoles(
2011 userId);
2012
2013 for (UserGroupRole oldUserGroupRole : oldUserGroupRoles) {
2014 if (!userGroupRoles.contains(oldUserGroupRole) &&
2015 !UserGroupRolePermissionUtil.contains(
2016 permissionChecker, oldUserGroupRole.getGroupId(),
2017 oldUserGroupRole.getRoleId())) {
2018
2019 userGroupRoles.add(oldUserGroupRole);
2020 }
2021 }
2022 }
2023
2024 for (UserGroupRole userGroupRole : userGroupRoles) {
2025 if ((oldUserGroupRoles == null) ||
2026 !oldUserGroupRoles.contains(userGroupRole)) {
2027
2028 UserGroupRolePermissionUtil.check(
2029 permissionChecker, userGroupRole.getGroupId(),
2030 userGroupRole.getRoleId());
2031 }
2032 }
2033
2034 return userGroupRoles;
2035 }
2036
2037 protected void updateAnnouncementsDeliveries(
2038 long userId, List<AnnouncementsDelivery> announcementsDeliveries)
2039 throws PortalException, SystemException {
2040
2041 for (AnnouncementsDelivery announcementsDelivery :
2042 announcementsDeliveries) {
2043
2044 announcementsDeliveryService.updateDelivery(
2045 userId, announcementsDelivery.getType(),
2046 announcementsDelivery.getEmail(),
2047 announcementsDelivery.getSms(),
2048 announcementsDelivery.getWebsite());
2049 }
2050 }
2051
2052 protected void validateEmailAddress(User user, String emailAddress)
2053 throws PortalException, SystemException {
2054
2055 PermissionChecker permissionChecker = getPermissionChecker();
2056
2057 if (!UsersAdminUtil.hasUpdateEmailAddress(permissionChecker, user)) {
2058 throw new UserEmailAddressException();
2059 }
2060
2061 if (!user.hasCompanyMx() && user.hasCompanyMx(emailAddress)) {
2062 Company company = companyPersistence.findByPrimaryKey(
2063 user.getCompanyId());
2064
2065 if (!company.isStrangersWithMx()) {
2066 throw new ReservedUserEmailAddressException();
2067 }
2068 }
2069 }
2070
2071 protected void validateOrganizationUsers(long[] userIds)
2072 throws PortalException, SystemException {
2073
2074 PermissionChecker permissionChecker = getPermissionChecker();
2075
2076 if (!PropsValues.ORGANIZATIONS_ASSIGNMENT_STRICT ||
2077 permissionChecker.isCompanyAdmin()) {
2078
2079 return;
2080 }
2081
2082 for (long userId : userIds) {
2083 boolean allowed = false;
2084
2085 List<Organization> organizations =
2086 organizationLocalService.getUserOrganizations(userId);
2087
2088 for (Organization organization : organizations) {
2089 if (OrganizationPermissionUtil.contains(
2090 permissionChecker, organization,
2091 ActionKeys.MANAGE_USERS)) {
2092
2093 allowed = true;
2094
2095 break;
2096 }
2097 }
2098
2099 if (!allowed) {
2100 throw new PrincipalException();
2101 }
2102 }
2103 }
2104
2105 protected void validateScreenName(User user, String screenName)
2106 throws PortalException, SystemException {
2107
2108 PermissionChecker permissionChecker = getPermissionChecker();
2109
2110 if (!UsersAdminUtil.hasUpdateScreenName(permissionChecker, user)) {
2111 throw new UserScreenNameException();
2112 }
2113 }
2114
2115 }