001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
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    /**
057     * @author Brian Wing Shun Chan
058     * @author Brian Myunghun Kim
059     * @author Scott Lee
060     * @author Jorge Ferrer
061     * @author Julio Camarero
062     */
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                            // Allow any user to join open communities
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                            // Allow any user to leave open and restricted communities
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                    // Add back any groups that the administrator does not have the rights
687                    // to remove and check that he has the permission to add any new group
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                    // Add back any organizations that the administrator does not have the
720                    // rights to remove and check that he has the permission to add any new
721                    // organization
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                    // Add back any roles that the administrator does not have the rights to
758                    // remove and check that he has the permission to add any new role
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                    // Add back any group roles that the administrator does not have the
792                    // rights to remove
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    }