001
014
015 package com.liferay.portlet.usersadmin.util;
016
017 import com.liferay.portal.kernel.configuration.Filter;
018 import com.liferay.portal.kernel.exception.PortalException;
019 import com.liferay.portal.kernel.language.LanguageUtil;
020 import com.liferay.portal.kernel.search.Document;
021 import com.liferay.portal.kernel.search.Field;
022 import com.liferay.portal.kernel.search.Hits;
023 import com.liferay.portal.kernel.search.Indexer;
024 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
025 import com.liferay.portal.kernel.security.pacl.DoPrivileged;
026 import com.liferay.portal.kernel.util.Accessor;
027 import com.liferay.portal.kernel.util.ArrayUtil;
028 import com.liferay.portal.kernel.util.GetterUtil;
029 import com.liferay.portal.kernel.util.ListUtil;
030 import com.liferay.portal.kernel.util.OrderByComparator;
031 import com.liferay.portal.kernel.util.ParamUtil;
032 import com.liferay.portal.kernel.util.PropsKeys;
033 import com.liferay.portal.kernel.util.SetUtil;
034 import com.liferay.portal.kernel.util.StringPool;
035 import com.liferay.portal.kernel.util.StringUtil;
036 import com.liferay.portal.kernel.util.Validator;
037 import com.liferay.portal.model.Address;
038 import com.liferay.portal.model.EmailAddress;
039 import com.liferay.portal.model.Group;
040 import com.liferay.portal.model.OrgLabor;
041 import com.liferay.portal.model.Organization;
042 import com.liferay.portal.model.Phone;
043 import com.liferay.portal.model.Role;
044 import com.liferay.portal.model.RoleConstants;
045 import com.liferay.portal.model.User;
046 import com.liferay.portal.model.UserGroup;
047 import com.liferay.portal.model.UserGroupRole;
048 import com.liferay.portal.model.Website;
049 import com.liferay.portal.security.auth.PrincipalThreadLocal;
050 import com.liferay.portal.security.membershippolicy.OrganizationMembershipPolicyUtil;
051 import com.liferay.portal.security.membershippolicy.SiteMembershipPolicyUtil;
052 import com.liferay.portal.security.permission.ActionKeys;
053 import com.liferay.portal.security.permission.PermissionChecker;
054 import com.liferay.portal.security.permission.PermissionThreadLocal;
055 import com.liferay.portal.service.AddressLocalServiceUtil;
056 import com.liferay.portal.service.AddressServiceUtil;
057 import com.liferay.portal.service.EmailAddressLocalServiceUtil;
058 import com.liferay.portal.service.EmailAddressServiceUtil;
059 import com.liferay.portal.service.GroupLocalServiceUtil;
060 import com.liferay.portal.service.OrgLaborLocalServiceUtil;
061 import com.liferay.portal.service.OrgLaborServiceUtil;
062 import com.liferay.portal.service.OrganizationLocalServiceUtil;
063 import com.liferay.portal.service.PhoneLocalServiceUtil;
064 import com.liferay.portal.service.PhoneServiceUtil;
065 import com.liferay.portal.service.RoleLocalServiceUtil;
066 import com.liferay.portal.service.ServiceContext;
067 import com.liferay.portal.service.UserGroupLocalServiceUtil;
068 import com.liferay.portal.service.UserGroupRoleLocalServiceUtil;
069 import com.liferay.portal.service.UserLocalServiceUtil;
070 import com.liferay.portal.service.WebsiteLocalServiceUtil;
071 import com.liferay.portal.service.WebsiteServiceUtil;
072 import com.liferay.portal.service.permission.GroupPermissionUtil;
073 import com.liferay.portal.service.permission.OrganizationPermissionUtil;
074 import com.liferay.portal.service.permission.RolePermissionUtil;
075 import com.liferay.portal.service.permission.UserGroupPermissionUtil;
076 import com.liferay.portal.service.permission.UserGroupRolePermissionUtil;
077 import com.liferay.portal.service.permission.UserPermissionUtil;
078 import com.liferay.portal.service.persistence.UserGroupRolePK;
079 import com.liferay.portal.util.PortalUtil;
080 import com.liferay.portal.util.PropsUtil;
081 import com.liferay.portal.util.PropsValues;
082 import com.liferay.portal.util.comparator.GroupNameComparator;
083 import com.liferay.portal.util.comparator.GroupTypeComparator;
084 import com.liferay.portal.util.comparator.OrganizationNameComparator;
085 import com.liferay.portal.util.comparator.OrganizationTypeComparator;
086 import com.liferay.portal.util.comparator.RoleDescriptionComparator;
087 import com.liferay.portal.util.comparator.RoleNameComparator;
088 import com.liferay.portal.util.comparator.RoleTypeComparator;
089 import com.liferay.portal.util.comparator.UserEmailAddressComparator;
090 import com.liferay.portal.util.comparator.UserFirstNameComparator;
091 import com.liferay.portal.util.comparator.UserGroupDescriptionComparator;
092 import com.liferay.portal.util.comparator.UserGroupNameComparator;
093 import com.liferay.portal.util.comparator.UserJobTitleComparator;
094 import com.liferay.portal.util.comparator.UserLastNameComparator;
095 import com.liferay.portal.util.comparator.UserScreenNameComparator;
096
097 import java.util.ArrayList;
098 import java.util.Collections;
099 import java.util.HashSet;
100 import java.util.Iterator;
101 import java.util.List;
102 import java.util.Locale;
103 import java.util.Set;
104
105 import javax.portlet.ActionRequest;
106 import javax.portlet.PortletRequest;
107 import javax.portlet.PortletURL;
108 import javax.portlet.RenderResponse;
109
110 import javax.servlet.http.HttpServletRequest;
111
112
117 @DoPrivileged
118 public class UsersAdminImpl implements UsersAdmin {
119
120 @Override
121 public void addPortletBreadcrumbEntries(
122 Organization organization, HttpServletRequest request,
123 RenderResponse renderResponse)
124 throws Exception {
125
126 PortletURL portletURL = renderResponse.createRenderURL();
127
128 portletURL.setParameter("struts_action", "/users_admin/view");
129
130 List<Organization> ancestorOrganizations = organization.getAncestors();
131
132 Collections.reverse(ancestorOrganizations);
133
134 for (Organization ancestorOrganization : ancestorOrganizations) {
135 portletURL.setParameter(
136 "organizationId",
137 String.valueOf(ancestorOrganization.getOrganizationId()));
138
139 PortalUtil.addPortletBreadcrumbEntry(
140 request, ancestorOrganization.getName(), portletURL.toString());
141 }
142
143 Organization unescapedOrganization = organization.toUnescapedModel();
144
145 portletURL.setParameter(
146 "organizationId",
147 String.valueOf(unescapedOrganization.getOrganizationId()));
148
149 PortalUtil.addPortletBreadcrumbEntry(
150 request, unescapedOrganization.getName(), portletURL.toString());
151 }
152
153 @Override
154 public long[] addRequiredRoles(long userId, long[] roleIds)
155 throws PortalException {
156
157 User user = UserLocalServiceUtil.getUser(userId);
158
159 return addRequiredRoles(user, roleIds);
160 }
161
162 @Override
163 public long[] addRequiredRoles(User user, long[] roleIds)
164 throws PortalException {
165
166 if (user.isDefaultUser()) {
167 return removeRequiredRoles(user, roleIds);
168 }
169
170 Role administratorRole = RoleLocalServiceUtil.getRole(
171 user.getCompanyId(), RoleConstants.ADMINISTRATOR);
172
173 long[] administratorUserIds = UserLocalServiceUtil.getRoleUserIds(
174 administratorRole.getRoleId());
175
176 if (ArrayUtil.contains(administratorUserIds, user.getUserId()) &&
177 !ArrayUtil.contains(roleIds, administratorRole.getRoleId()) &&
178 (administratorUserIds.length == 1)) {
179
180 roleIds = ArrayUtil.append(roleIds, administratorRole.getRoleId());
181 }
182
183 Role userRole = RoleLocalServiceUtil.getRole(
184 user.getCompanyId(), RoleConstants.USER);
185
186 if (!ArrayUtil.contains(roleIds, userRole.getRoleId())) {
187 roleIds = ArrayUtil.append(roleIds, userRole.getRoleId());
188 }
189
190 return roleIds;
191 }
192
193 @Override
194 public List<Role> filterGroupRoles(
195 PermissionChecker permissionChecker, long groupId, List<Role> roles)
196 throws PortalException {
197
198 List<Role> filteredGroupRoles = ListUtil.copy(roles);
199
200 Iterator<Role> itr = filteredGroupRoles.iterator();
201
202 while (itr.hasNext()) {
203 Role groupRole = itr.next();
204
205 String roleName = groupRole.getName();
206
207 if (roleName.equals(RoleConstants.ORGANIZATION_USER) ||
208 roleName.equals(RoleConstants.SITE_MEMBER)) {
209
210 itr.remove();
211 }
212 }
213
214 if (permissionChecker.isCompanyAdmin() ||
215 permissionChecker.isGroupOwner(groupId)) {
216
217 return filteredGroupRoles;
218 }
219
220 Group group = GroupLocalServiceUtil.getGroup(groupId);
221
222 if (!GroupPermissionUtil.contains(
223 permissionChecker, group, ActionKeys.ASSIGN_USER_ROLES) &&
224 !OrganizationPermissionUtil.contains(
225 permissionChecker, group.getOrganizationId(),
226 ActionKeys.ASSIGN_USER_ROLES)) {
227
228 return Collections.emptyList();
229 }
230
231 itr = filteredGroupRoles.iterator();
232
233 while (itr.hasNext()) {
234 Role groupRole = itr.next();
235
236 String roleName = groupRole.getName();
237
238 if (roleName.equals(
239 RoleConstants.ORGANIZATION_ADMINISTRATOR) ||
240 roleName.equals(RoleConstants.ORGANIZATION_OWNER) ||
241 roleName.equals(RoleConstants.SITE_ADMINISTRATOR) ||
242 roleName.equals(RoleConstants.SITE_OWNER) ||
243 !RolePermissionUtil.contains(
244 permissionChecker, groupId, groupRole.getRoleId(),
245 ActionKeys.ASSIGN_MEMBERS)) {
246
247 itr.remove();
248 }
249 }
250
251 return filteredGroupRoles;
252 }
253
254 @Override
255 public List<Group> filterGroups(
256 PermissionChecker permissionChecker, List<Group> groups)
257 throws PortalException {
258
259 if (permissionChecker.isCompanyAdmin()) {
260 return groups;
261 }
262
263 List<Group> filteredGroups = ListUtil.copy(groups);
264
265 Iterator<Group> itr = filteredGroups.iterator();
266
267 while (itr.hasNext()) {
268 Group group = itr.next();
269
270 if (!GroupPermissionUtil.contains(
271 permissionChecker, group, ActionKeys.ASSIGN_MEMBERS)) {
272
273 itr.remove();
274 }
275 }
276
277 return filteredGroups;
278 }
279
280 @Override
281 public List<Organization> filterOrganizations(
282 PermissionChecker permissionChecker,
283 List<Organization> organizations)
284 throws PortalException {
285
286 if (permissionChecker.isCompanyAdmin()) {
287 return organizations;
288 }
289
290 List<Organization> filteredOrganizations = ListUtil.copy(organizations);
291
292 Iterator<Organization> itr = filteredOrganizations.iterator();
293
294 while (itr.hasNext()) {
295 Organization organization = itr.next();
296
297 if (!OrganizationPermissionUtil.contains(
298 permissionChecker, organization,
299 ActionKeys.ASSIGN_MEMBERS)) {
300
301 itr.remove();
302 }
303 }
304
305 return filteredOrganizations;
306 }
307
308 @Override
309 public List<Role> filterRoles(
310 PermissionChecker permissionChecker, List<Role> roles) {
311
312 List<Role> filteredRoles = ListUtil.copy(roles);
313
314 Iterator<Role> itr = filteredRoles.iterator();
315
316 while (itr.hasNext()) {
317 Role role = itr.next();
318
319 String roleName = role.getName();
320
321 if (roleName.equals(RoleConstants.GUEST) ||
322 roleName.equals(RoleConstants.ORGANIZATION_USER) ||
323 roleName.equals(RoleConstants.OWNER) ||
324 roleName.equals(RoleConstants.SITE_MEMBER) ||
325 roleName.equals(RoleConstants.USER)) {
326
327 itr.remove();
328 }
329 }
330
331 if (permissionChecker.isCompanyAdmin()) {
332 return filteredRoles;
333 }
334
335 itr = filteredRoles.iterator();
336
337 while (itr.hasNext()) {
338 Role role = itr.next();
339
340 if (!RolePermissionUtil.contains(
341 permissionChecker, role.getRoleId(),
342 ActionKeys.ASSIGN_MEMBERS)) {
343
344 itr.remove();
345 }
346 }
347
348 return filteredRoles;
349 }
350
351 @Override
352 public long[] filterUnsetGroupUserIds(
353 PermissionChecker permissionChecker, long groupId, long[] userIds)
354 throws PortalException {
355
356 long[] filteredUserIds = userIds;
357
358 for (long userId : userIds) {
359 if (SiteMembershipPolicyUtil.isMembershipProtected(
360 permissionChecker, userId, groupId)) {
361
362 filteredUserIds = ArrayUtil.remove(filteredUserIds, userId);
363 }
364 }
365
366 return filteredUserIds;
367 }
368
369 @Override
370 public long[] filterUnsetOrganizationUserIds(
371 PermissionChecker permissionChecker, long organizationId,
372 long[] userIds)
373 throws PortalException {
374
375 long[] filteredUserIds = userIds;
376
377 for (long userId : userIds) {
378 if (OrganizationMembershipPolicyUtil.isMembershipProtected(
379 permissionChecker, userId, organizationId)) {
380
381 filteredUserIds = ArrayUtil.remove(filteredUserIds, userId);
382 }
383 }
384
385 return filteredUserIds;
386 }
387
388 @Override
389 public List<UserGroupRole> filterUserGroupRoles(
390 PermissionChecker permissionChecker,
391 List<UserGroupRole> userGroupRoles)
392 throws PortalException {
393
394 List<UserGroupRole> filteredUserGroupRoles = ListUtil.copy(
395 userGroupRoles);
396
397 Iterator<UserGroupRole> itr = filteredUserGroupRoles.iterator();
398
399 while (itr.hasNext()) {
400 UserGroupRole userGroupRole = itr.next();
401
402 Role role = userGroupRole.getRole();
403
404 String roleName = role.getName();
405
406 if (roleName.equals(RoleConstants.ORGANIZATION_USER) ||
407 roleName.equals(RoleConstants.SITE_MEMBER)) {
408
409 itr.remove();
410 }
411 }
412
413 if (permissionChecker.isCompanyAdmin()) {
414 return filteredUserGroupRoles;
415 }
416
417 itr = filteredUserGroupRoles.iterator();
418
419 while (itr.hasNext()) {
420 UserGroupRole userGroupRole = itr.next();
421
422 if (!UserGroupRolePermissionUtil.contains(
423 permissionChecker, userGroupRole.getGroupId(),
424 userGroupRole.getRoleId())) {
425
426 itr.remove();
427 }
428 }
429
430 return filteredUserGroupRoles;
431 }
432
433 @Override
434 public List<UserGroup> filterUserGroups(
435 PermissionChecker permissionChecker, List<UserGroup> userGroups) {
436
437 if (permissionChecker.isCompanyAdmin()) {
438 return userGroups;
439 }
440
441 List<UserGroup> filteredUserGroups = ListUtil.copy(userGroups);
442
443 Iterator<UserGroup> itr = filteredUserGroups.iterator();
444
445 while (itr.hasNext()) {
446 UserGroup userGroup = itr.next();
447
448 if (!UserGroupPermissionUtil.contains(
449 permissionChecker, userGroup.getUserGroupId(),
450 ActionKeys.ASSIGN_MEMBERS)) {
451
452 itr.remove();
453 }
454 }
455
456 return filteredUserGroups;
457 }
458
459 @Override
460 public List<Address> getAddresses(ActionRequest actionRequest) {
461 return getAddresses(actionRequest, Collections.<Address>emptyList());
462 }
463
464 @Override
465 public List<Address> getAddresses(
466 ActionRequest actionRequest, List<Address> defaultAddresses) {
467
468 String addressesIndexesString = actionRequest.getParameter(
469 "addressesIndexes");
470
471 if (addressesIndexesString == null) {
472 return defaultAddresses;
473 }
474
475 List<Address> addresses = new ArrayList<>();
476
477 int[] addressesIndexes = StringUtil.split(addressesIndexesString, 0);
478
479 int addressPrimary = ParamUtil.getInteger(
480 actionRequest, "addressPrimary");
481
482 for (int addressesIndex : addressesIndexes) {
483 long addressId = ParamUtil.getLong(
484 actionRequest, "addressId" + addressesIndex);
485
486 String street1 = ParamUtil.getString(
487 actionRequest, "addressStreet1_" + addressesIndex);
488 String street2 = ParamUtil.getString(
489 actionRequest, "addressStreet2_" + addressesIndex);
490 String street3 = ParamUtil.getString(
491 actionRequest, "addressStreet3_" + addressesIndex);
492 String city = ParamUtil.getString(
493 actionRequest, "addressCity" + addressesIndex);
494 String zip = ParamUtil.getString(
495 actionRequest, "addressZip" + addressesIndex);
496 long countryId = ParamUtil.getLong(
497 actionRequest, "addressCountryId" + addressesIndex);
498
499 if (Validator.isNull(street1) && Validator.isNull(street2) &&
500 Validator.isNull(street3) && Validator.isNull(city) &&
501 Validator.isNull(zip) && (countryId == 0)) {
502
503 continue;
504 }
505
506 long regionId = ParamUtil.getLong(
507 actionRequest, "addressRegionId" + addressesIndex);
508 long typeId = ParamUtil.getLong(
509 actionRequest, "addressTypeId" + addressesIndex);
510 boolean mailing = ParamUtil.getBoolean(
511 actionRequest, "addressMailing" + addressesIndex);
512
513 boolean primary = false;
514
515 if (addressesIndex == addressPrimary) {
516 primary = true;
517 }
518
519 Address address = AddressLocalServiceUtil.createAddress(addressId);
520
521 address.setStreet1(street1);
522 address.setStreet2(street2);
523 address.setStreet3(street3);
524 address.setCity(city);
525 address.setZip(zip);
526 address.setRegionId(regionId);
527 address.setCountryId(countryId);
528 address.setTypeId(typeId);
529 address.setMailing(mailing);
530 address.setPrimary(primary);
531
532 addresses.add(address);
533 }
534
535 return addresses;
536 }
537
538 @Override
539 public List<EmailAddress> getEmailAddresses(ActionRequest actionRequest) {
540 return getEmailAddresses(
541 actionRequest, Collections.<EmailAddress>emptyList());
542 }
543
544 @Override
545 public List<EmailAddress> getEmailAddresses(
546 ActionRequest actionRequest, List<EmailAddress> defaultEmailAddresses) {
547
548 String emailAddressesIndexesString = actionRequest.getParameter(
549 "emailAddressesIndexes");
550
551 if (emailAddressesIndexesString == null) {
552 return defaultEmailAddresses;
553 }
554
555 List<EmailAddress> emailAddresses = new ArrayList<>();
556
557 int[] emailAddressesIndexes = StringUtil.split(
558 emailAddressesIndexesString, 0);
559
560 int emailAddressPrimary = ParamUtil.getInteger(
561 actionRequest, "emailAddressPrimary");
562
563 for (int emailAddressesIndex : emailAddressesIndexes) {
564 long emailAddressId = ParamUtil.getLong(
565 actionRequest, "emailAddressId" + emailAddressesIndex);
566
567 String address = ParamUtil.getString(
568 actionRequest, "emailAddressAddress" + emailAddressesIndex);
569
570 if (Validator.isNull(address)) {
571 continue;
572 }
573
574 long typeId = ParamUtil.getLong(
575 actionRequest, "emailAddressTypeId" + emailAddressesIndex);
576
577 boolean primary = false;
578
579 if (emailAddressesIndex == emailAddressPrimary) {
580 primary = true;
581 }
582
583 EmailAddress emailAddress =
584 EmailAddressLocalServiceUtil.createEmailAddress(emailAddressId);
585
586 emailAddress.setAddress(address);
587 emailAddress.setTypeId(typeId);
588 emailAddress.setPrimary(primary);
589
590 emailAddresses.add(emailAddress);
591 }
592
593 return emailAddresses;
594 }
595
596 @Override
597 public long[] getGroupIds(PortletRequest portletRequest)
598 throws PortalException {
599
600 User user = PortalUtil.getSelectedUser(portletRequest);
601
602 if (user == null) {
603 return null;
604 }
605
606 return getRequestPrimaryKeys(
607 portletRequest, user.getGroupIds(), "addGroupIds",
608 "deleteGroupIds");
609 }
610
611 @Override
612 public OrderByComparator<Group> getGroupOrderByComparator(
613 String orderByCol, String orderByType) {
614
615 boolean orderByAsc = false;
616
617 if (orderByType.equals("asc")) {
618 orderByAsc = true;
619 }
620
621 OrderByComparator<Group> orderByComparator = null;
622
623 if (orderByCol.equals("name")) {
624 orderByComparator = new GroupNameComparator(orderByAsc);
625 }
626 else if (orderByCol.equals("type")) {
627 orderByComparator = new GroupTypeComparator(orderByAsc);
628 }
629 else {
630 orderByComparator = new GroupNameComparator(orderByAsc);
631 }
632
633 return orderByComparator;
634 }
635
636 @Override
637 public Long[] getOrganizationIds(List<Organization> organizations) {
638 if ((organizations == null) || organizations.isEmpty()) {
639 return new Long[0];
640 }
641
642 Long[] organizationIds = new Long[organizations.size()];
643
644 for (int i = 0; i < organizations.size(); i++) {
645 Organization organization = organizations.get(i);
646
647 organizationIds[i] = new Long(organization.getOrganizationId());
648 }
649
650 return organizationIds;
651 }
652
653 @Override
654 public long[] getOrganizationIds(PortletRequest portletRequest)
655 throws PortalException {
656
657 User user = PortalUtil.getSelectedUser(portletRequest);
658
659 if (user == null) {
660 return null;
661 }
662
663 return getRequestPrimaryKeys(
664 portletRequest, user.getOrganizationIds(), "addOrganizationIds",
665 "deleteOrganizationIds");
666 }
667
668 @Override
669 public OrderByComparator<Organization> getOrganizationOrderByComparator(
670 String orderByCol, String orderByType) {
671
672 boolean orderByAsc = false;
673
674 if (orderByType.equals("asc")) {
675 orderByAsc = true;
676 }
677
678 OrderByComparator<Organization> orderByComparator = null;
679
680 if (orderByCol.equals("name")) {
681 orderByComparator = new OrganizationNameComparator(orderByAsc);
682 }
683 else if (orderByCol.equals("type")) {
684 orderByComparator = new OrganizationTypeComparator(orderByAsc);
685 }
686 else {
687 orderByComparator = new OrganizationNameComparator(orderByAsc);
688 }
689
690 return orderByComparator;
691 }
692
693 @Override
694 public List<Organization> getOrganizations(Hits hits)
695 throws PortalException {
696
697 List<Document> documents = hits.toList();
698
699 List<Organization> organizations = new ArrayList<>(documents.size());
700
701 for (Document document : documents) {
702 long organizationId = GetterUtil.getLong(
703 document.get(Field.ORGANIZATION_ID));
704
705 Organization organization =
706 OrganizationLocalServiceUtil.fetchOrganization(organizationId);
707
708 if (organization == null) {
709 organizations = null;
710
711 Indexer indexer = IndexerRegistryUtil.getIndexer(
712 Organization.class);
713
714 long companyId = GetterUtil.getLong(
715 document.get(Field.COMPANY_ID));
716
717 indexer.delete(companyId, document.getUID());
718 }
719 else if (organizations != null) {
720 organizations.add(organization);
721 }
722 }
723
724 return organizations;
725 }
726
727 @Override
728 public List<OrgLabor> getOrgLabors(ActionRequest actionRequest) {
729 List<OrgLabor> orgLabors = new ArrayList<>();
730
731 int[] orgLaborsIndexes = StringUtil.split(
732 ParamUtil.getString(actionRequest, "orgLaborsIndexes"), 0);
733
734 for (int orgLaborsIndex : orgLaborsIndexes) {
735 long orgLaborId = ParamUtil.getLong(
736 actionRequest, "orgLaborId" + orgLaborsIndex);
737
738 long typeId = ParamUtil.getLong(
739 actionRequest, "orgLaborTypeId" + orgLaborsIndex, -1);
740
741 if (typeId == -1) {
742 continue;
743 }
744
745 int sunOpen = ParamUtil.getInteger(
746 actionRequest, "sunOpen" + orgLaborsIndex, -1);
747 int sunClose = ParamUtil.getInteger(
748 actionRequest, "sunClose" + orgLaborsIndex, -1);
749 int monOpen = ParamUtil.getInteger(
750 actionRequest, "monOpen" + orgLaborsIndex, -1);
751 int monClose = ParamUtil.getInteger(
752 actionRequest, "monClose" + orgLaborsIndex, -1);
753 int tueOpen = ParamUtil.getInteger(
754 actionRequest, "tueOpen" + orgLaborsIndex, -1);
755 int tueClose = ParamUtil.getInteger(
756 actionRequest, "tueClose" + orgLaborsIndex, -1);
757 int wedOpen = ParamUtil.getInteger(
758 actionRequest, "wedOpen" + orgLaborsIndex, -1);
759 int wedClose = ParamUtil.getInteger(
760 actionRequest, "wedClose" + orgLaborsIndex, -1);
761 int thuOpen = ParamUtil.getInteger(
762 actionRequest, "thuOpen" + orgLaborsIndex, -1);
763 int thuClose = ParamUtil.getInteger(
764 actionRequest, "thuClose" + orgLaborsIndex, -1);
765 int friOpen = ParamUtil.getInteger(
766 actionRequest, "friOpen" + orgLaborsIndex, -1);
767 int friClose = ParamUtil.getInteger(
768 actionRequest, "friClose" + orgLaborsIndex, -1);
769 int satOpen = ParamUtil.getInteger(
770 actionRequest, "satOpen" + orgLaborsIndex, -1);
771 int satClose = ParamUtil.getInteger(
772 actionRequest, "satClose" + orgLaborsIndex, -1);
773
774 OrgLabor orgLabor = OrgLaborLocalServiceUtil.createOrgLabor(
775 orgLaborId);
776
777 orgLabor.setTypeId(typeId);
778 orgLabor.setSunOpen(sunOpen);
779 orgLabor.setSunClose(sunClose);
780 orgLabor.setMonOpen(monOpen);
781 orgLabor.setMonClose(monClose);
782 orgLabor.setTueOpen(tueOpen);
783 orgLabor.setTueClose(tueClose);
784 orgLabor.setWedOpen(wedOpen);
785 orgLabor.setWedClose(wedClose);
786 orgLabor.setThuOpen(thuOpen);
787 orgLabor.setThuClose(thuClose);
788 orgLabor.setFriOpen(friOpen);
789 orgLabor.setFriClose(friClose);
790 orgLabor.setSatOpen(satOpen);
791 orgLabor.setSatClose(satClose);
792
793 orgLabors.add(orgLabor);
794 }
795
796 return orgLabors;
797 }
798
799 @Override
800 public List<Phone> getPhones(ActionRequest actionRequest) {
801 return getPhones(actionRequest, Collections.<Phone>emptyList());
802 }
803
804 @Override
805 public List<Phone> getPhones(
806 ActionRequest actionRequest, List<Phone> defaultPhones) {
807
808 String phonesIndexesString = actionRequest.getParameter(
809 "phonesIndexes");
810
811 if (phonesIndexesString == null) {
812 return defaultPhones;
813 }
814
815 List<Phone> phones = new ArrayList<>();
816
817 int[] phonesIndexes = StringUtil.split(phonesIndexesString, 0);
818
819 int phonePrimary = ParamUtil.getInteger(actionRequest, "phonePrimary");
820
821 for (int phonesIndex : phonesIndexes) {
822 long phoneId = ParamUtil.getLong(
823 actionRequest, "phoneId" + phonesIndex);
824
825 String number = ParamUtil.getString(
826 actionRequest, "phoneNumber" + phonesIndex);
827 String extension = ParamUtil.getString(
828 actionRequest, "phoneExtension" + phonesIndex);
829
830 if (Validator.isNull(number) && Validator.isNull(extension)) {
831 continue;
832 }
833
834 long typeId = ParamUtil.getLong(
835 actionRequest, "phoneTypeId" + phonesIndex);
836
837 boolean primary = false;
838
839 if (phonesIndex == phonePrimary) {
840 primary = true;
841 }
842
843 Phone phone = PhoneLocalServiceUtil.createPhone(phoneId);
844
845 phone.setNumber(number);
846 phone.setExtension(extension);
847 phone.setTypeId(typeId);
848 phone.setPrimary(primary);
849
850 phones.add(phone);
851 }
852
853 return phones;
854 }
855
856 @Override
857 public long[] getRoleIds(PortletRequest portletRequest)
858 throws PortalException {
859
860 User user = PortalUtil.getSelectedUser(portletRequest);
861
862 if (user == null) {
863 return null;
864 }
865
866 return getRequestPrimaryKeys(
867 portletRequest, user.getRoleIds(), "addRoleIds", "deleteRoleIds");
868 }
869
870 @Override
871 public OrderByComparator<Role> getRoleOrderByComparator(
872 String orderByCol, String orderByType) {
873
874 boolean orderByAsc = false;
875
876 if (orderByType.equals("asc")) {
877 orderByAsc = true;
878 }
879
880 OrderByComparator<Role> orderByComparator = null;
881
882 if (orderByCol.equals("name")) {
883 orderByComparator = new RoleNameComparator(orderByAsc);
884 }
885 else if (orderByCol.equals("description")) {
886 orderByComparator = new RoleDescriptionComparator(orderByAsc);
887 }
888 else if (orderByCol.equals("type")) {
889 orderByComparator = new RoleTypeComparator(orderByAsc);
890 }
891 else {
892 orderByComparator = new RoleNameComparator(orderByAsc);
893 }
894
895 return orderByComparator;
896 }
897
898 @Override
899 public <T> String getUserColumnText(
900 Locale locale, List<? extends T> list, Accessor<T, String> accessor,
901 int count) {
902
903 String result = ListUtil.toString(
904 list, accessor, StringPool.COMMA_AND_SPACE);
905
906 if (list.size() < count) {
907 result += StringPool.SPACE + LanguageUtil.format(
908 locale, "and-x-more", String.valueOf(count - list.size()),
909 false);
910 }
911
912 return result;
913 }
914
915 @Override
916 public long[] getUserGroupIds(PortletRequest portletRequest)
917 throws PortalException {
918
919 User user = PortalUtil.getSelectedUser(portletRequest);
920
921 if (user == null) {
922 return null;
923 }
924
925 return getRequestPrimaryKeys(
926 portletRequest, user.getUserGroupIds(), "addUserGroupIds",
927 "deleteUserGroupIds");
928 }
929
930 @Override
931 public OrderByComparator<UserGroup> getUserGroupOrderByComparator(
932 String orderByCol, String orderByType) {
933
934 boolean orderByAsc = false;
935
936 if (orderByType.equals("asc")) {
937 orderByAsc = true;
938 }
939
940 OrderByComparator<UserGroup> orderByComparator = null;
941
942 if (orderByCol.equals("name")) {
943 orderByComparator = new UserGroupNameComparator(orderByAsc);
944 }
945 else if (orderByCol.equals("description")) {
946 orderByComparator = new UserGroupDescriptionComparator(orderByAsc);
947 }
948 else {
949 orderByComparator = new UserGroupNameComparator(orderByAsc);
950 }
951
952 return orderByComparator;
953 }
954
955 @Override
956 public List<UserGroupRole> getUserGroupRoles(PortletRequest portletRequest)
957 throws PortalException {
958
959 User user = PortalUtil.getSelectedUser(portletRequest);
960
961 if (user == null) {
962 return Collections.emptyList();
963 }
964
965 Set<UserGroupRole> userGroupRoles = new HashSet<>(
966 UserGroupRoleLocalServiceUtil.getUserGroupRoles(user.getUserId()));
967
968 userGroupRoles.addAll(
969 getUserGroupRoles(
970 portletRequest, user, "addGroupRolesGroupIds",
971 "addGroupRolesRoleIds"));
972 userGroupRoles.removeAll(
973 getUserGroupRoles(
974 portletRequest, user, "deleteGroupRolesGroupIds",
975 "deleteGroupRolesRoleIds"));
976
977 return new ArrayList<>(userGroupRoles);
978 }
979
980 @Override
981 public List<UserGroup> getUserGroups(Hits hits) throws PortalException {
982 List<Document> documents = hits.toList();
983
984 List<UserGroup> userGroups = new ArrayList<>(documents.size());
985
986 for (Document document : documents) {
987 long userGroupId = GetterUtil.getLong(
988 document.get(Field.USER_GROUP_ID));
989
990 UserGroup userGroup = UserGroupLocalServiceUtil.fetchUserGroup(
991 userGroupId);
992
993 if (userGroup == null) {
994 userGroups = null;
995
996 Indexer indexer = IndexerRegistryUtil.getIndexer(
997 UserGroup.class);
998
999 long companyId = GetterUtil.getLong(
1000 document.get(Field.COMPANY_ID));
1001
1002 indexer.delete(companyId, document.getUID());
1003 }
1004 else if (userGroups != null) {
1005 userGroups.add(userGroup);
1006 }
1007 }
1008
1009 return userGroups;
1010 }
1011
1012 @Override
1013 public OrderByComparator<User> getUserOrderByComparator(
1014 String orderByCol, String orderByType) {
1015
1016 boolean orderByAsc = false;
1017
1018 if (orderByType.equals("asc")) {
1019 orderByAsc = true;
1020 }
1021
1022 OrderByComparator<User> orderByComparator = null;
1023
1024 if (orderByCol.equals("email-address")) {
1025 orderByComparator = new UserEmailAddressComparator(orderByAsc);
1026 }
1027 else if (orderByCol.equals("first-name")) {
1028 orderByComparator = new UserFirstNameComparator(orderByAsc);
1029 }
1030 else if (orderByCol.equals("job-title")) {
1031 orderByComparator = new UserJobTitleComparator(orderByAsc);
1032 }
1033 else if (orderByCol.equals("last-name")) {
1034 orderByComparator = new UserLastNameComparator(orderByAsc);
1035 }
1036 else if (orderByCol.equals("screen-name")) {
1037 orderByComparator = new UserScreenNameComparator(orderByAsc);
1038 }
1039 else {
1040 orderByComparator = new UserLastNameComparator(orderByAsc);
1041 }
1042
1043 return orderByComparator;
1044 }
1045
1046 @Override
1047 public List<User> getUsers(Hits hits) throws PortalException {
1048 List<Document> documents = hits.toList();
1049
1050 List<User> users = new ArrayList<>(documents.size());
1051
1052 for (Document document : documents) {
1053 long userId = UserIndexer.getUserId(document);
1054
1055 User user = UserLocalServiceUtil.fetchUser(userId);
1056
1057 if (user == null) {
1058 users = null;
1059
1060 Indexer indexer = IndexerRegistryUtil.getIndexer(User.class);
1061
1062 long companyId = GetterUtil.getLong(
1063 document.get(Field.COMPANY_ID));
1064
1065 indexer.delete(companyId, document.getUID());
1066 }
1067 else if (users != null) {
1068 users.add(user);
1069 }
1070 }
1071
1072 return users;
1073 }
1074
1075 @Override
1076 public List<Website> getWebsites(ActionRequest actionRequest) {
1077 return getWebsites(actionRequest, Collections.<Website>emptyList());
1078 }
1079
1080 @Override
1081 public List<Website> getWebsites(
1082 ActionRequest actionRequest, List<Website> defaultWebsites) {
1083
1084 String websitesIndexesString = actionRequest.getParameter(
1085 "websitesIndexes");
1086
1087 if (websitesIndexesString == null) {
1088 return defaultWebsites;
1089 }
1090
1091 List<Website> websites = new ArrayList<>();
1092
1093 int[] websitesIndexes = StringUtil.split(websitesIndexesString, 0);
1094
1095 int websitePrimary = ParamUtil.getInteger(
1096 actionRequest, "websitePrimary");
1097
1098 for (int websitesIndex : websitesIndexes) {
1099 long websiteId = ParamUtil.getLong(
1100 actionRequest, "websiteId" + websitesIndex);
1101
1102 String url = ParamUtil.getString(
1103 actionRequest, "websiteUrl" + websitesIndex);
1104
1105 if (Validator.isNull(url)) {
1106 continue;
1107 }
1108
1109 long typeId = ParamUtil.getLong(
1110 actionRequest, "websiteTypeId" + websitesIndex);
1111
1112 boolean primary = false;
1113
1114 if (websitesIndex == websitePrimary) {
1115 primary = true;
1116 }
1117
1118 Website website = WebsiteLocalServiceUtil.createWebsite(websiteId);
1119
1120 website.setUrl(url);
1121 website.setTypeId(typeId);
1122 website.setPrimary(primary);
1123
1124 websites.add(website);
1125 }
1126
1127 return websites;
1128 }
1129
1130
1135 @Deprecated
1136 @Override
1137 public boolean hasUpdateEmailAddress(
1138 PermissionChecker permissionChecker, User user)
1139 throws PortalException {
1140
1141 return hasUpdateFieldPermission(
1142 permissionChecker, null, user, "emailAddress");
1143 }
1144
1145 @Override
1146 public boolean hasUpdateFieldPermission(
1147 PermissionChecker permissionChecker, User updatingUser,
1148 User updatedUser, String field)
1149 throws PortalException {
1150
1151 if (updatedUser == null) {
1152 return true;
1153 }
1154
1155 if (updatingUser == null) {
1156 long updatingUserId = PrincipalThreadLocal.getUserId();
1157
1158 if (updatingUserId > 0) {
1159 updatingUser = UserLocalServiceUtil.fetchUserById(
1160 updatingUserId);
1161 }
1162 }
1163
1164 if ((updatingUser != null) && !updatingUser.equals(updatedUser) &&
1165 UserPermissionUtil.contains(
1166 permissionChecker, updatingUser.getUserId(),
1167 ActionKeys.UPDATE_USER)) {
1168
1169 return true;
1170 }
1171
1172 for (String userType : PropsValues.FIELD_EDITABLE_USER_TYPES) {
1173 if (userType.equals("user-with-mx") && updatedUser.hasCompanyMx()) {
1174 return true;
1175 }
1176
1177 if (userType.equals("user-without-mx") &&
1178 !updatedUser.hasCompanyMx()) {
1179
1180 return true;
1181 }
1182 }
1183
1184 for (String roleName : PropsValues.FIELD_EDITABLE_ROLES) {
1185 Role role = RoleLocalServiceUtil.fetchRole(
1186 updatedUser.getCompanyId(), roleName);
1187
1188 if ((role != null) &&
1189 RoleLocalServiceUtil.hasUserRole(
1190 updatedUser.getUserId(), role.getRoleId())) {
1191
1192 return true;
1193 }
1194 }
1195
1196 String emailAddress = updatedUser.getEmailAddress();
1197
1198 for (String domainName : PropsValues.FIELD_EDITABLE_DOMAINS) {
1199 if (emailAddress.endsWith(domainName)) {
1200 return true;
1201 }
1202 }
1203
1204 String[] fieldEditableDomainNames = PropsUtil.getArray(
1205 PropsKeys.FIELD_EDITABLE_DOMAINS, new Filter(field));
1206
1207 for (String domainName : fieldEditableDomainNames) {
1208 if (domainName.equals(StringPool.STAR) ||
1209 emailAddress.endsWith(domainName)) {
1210
1211 return true;
1212 }
1213 }
1214
1215 return false;
1216 }
1217
1218
1223 @Deprecated
1224 @Override
1225 public boolean hasUpdateFieldPermission(User user, String field)
1226 throws PortalException {
1227
1228 PermissionChecker permissionChecker =
1229 PermissionThreadLocal.getPermissionChecker();
1230
1231 return hasUpdateFieldPermission(permissionChecker, null, user, field);
1232 }
1233
1234
1239 @Deprecated
1240 @Override
1241 public boolean hasUpdateScreenName(
1242 PermissionChecker permissionChecker, User user)
1243 throws PortalException {
1244
1245 return hasUpdateFieldPermission(
1246 permissionChecker, null, user, "screenName");
1247 }
1248
1249 @Override
1250 public long[] removeRequiredRoles(long userId, long[] roleIds)
1251 throws PortalException {
1252
1253 User user = UserLocalServiceUtil.getUser(userId);
1254
1255 return removeRequiredRoles(user, roleIds);
1256 }
1257
1258 @Override
1259 public long[] removeRequiredRoles(User user, long[] roleIds)
1260 throws PortalException {
1261
1262 Role role = RoleLocalServiceUtil.getRole(
1263 user.getCompanyId(), RoleConstants.USER);
1264
1265 roleIds = ArrayUtil.remove(roleIds, role.getRoleId());
1266
1267 return roleIds;
1268 }
1269
1270 @Override
1271 public void updateAddresses(
1272 String className, long classPK, List<Address> addresses)
1273 throws PortalException {
1274
1275 Set<Long> addressIds = new HashSet<>();
1276
1277 for (Address address : addresses) {
1278 long addressId = address.getAddressId();
1279
1280 String street1 = address.getStreet1();
1281 String street2 = address.getStreet2();
1282 String street3 = address.getStreet3();
1283 String city = address.getCity();
1284 String zip = address.getZip();
1285 long regionId = address.getRegionId();
1286 long countryId = address.getCountryId();
1287 long typeId = address.getTypeId();
1288 boolean mailing = address.isMailing();
1289 boolean primary = address.isPrimary();
1290
1291 if (addressId <= 0) {
1292 address = AddressServiceUtil.addAddress(
1293 className, classPK, street1, street2, street3, city, zip,
1294 regionId, countryId, typeId, mailing, primary,
1295 new ServiceContext());
1296
1297 addressId = address.getAddressId();
1298 }
1299 else {
1300 AddressServiceUtil.updateAddress(
1301 addressId, street1, street2, street3, city, zip, regionId,
1302 countryId, typeId, mailing, primary);
1303 }
1304
1305 addressIds.add(addressId);
1306 }
1307
1308 addresses = AddressServiceUtil.getAddresses(className, classPK);
1309
1310 for (Address address : addresses) {
1311 if (!addressIds.contains(address.getAddressId())) {
1312 AddressServiceUtil.deleteAddress(address.getAddressId());
1313 }
1314 }
1315 }
1316
1317 @Override
1318 public void updateEmailAddresses(
1319 String className, long classPK, List<EmailAddress> emailAddresses)
1320 throws PortalException {
1321
1322 Set<Long> emailAddressIds = new HashSet<>();
1323
1324 for (EmailAddress emailAddress : emailAddresses) {
1325 long emailAddressId = emailAddress.getEmailAddressId();
1326
1327 String address = emailAddress.getAddress();
1328 long typeId = emailAddress.getTypeId();
1329 boolean primary = emailAddress.isPrimary();
1330
1331 if (emailAddressId <= 0) {
1332 emailAddress = EmailAddressServiceUtil.addEmailAddress(
1333 className, classPK, address, typeId, primary,
1334 new ServiceContext());
1335
1336 emailAddressId = emailAddress.getEmailAddressId();
1337 }
1338 else {
1339 EmailAddressServiceUtil.updateEmailAddress(
1340 emailAddressId, address, typeId, primary);
1341 }
1342
1343 emailAddressIds.add(emailAddressId);
1344 }
1345
1346 emailAddresses = EmailAddressServiceUtil.getEmailAddresses(
1347 className, classPK);
1348
1349 for (EmailAddress emailAddress : emailAddresses) {
1350 if (!emailAddressIds.contains(emailAddress.getEmailAddressId())) {
1351 EmailAddressServiceUtil.deleteEmailAddress(
1352 emailAddress.getEmailAddressId());
1353 }
1354 }
1355 }
1356
1357 @Override
1358 public void updateOrgLabors(long classPK, List<OrgLabor> orgLabors)
1359 throws PortalException {
1360
1361 Set<Long> orgLaborsIds = new HashSet<>();
1362
1363 for (OrgLabor orgLabor : orgLabors) {
1364 long orgLaborId = orgLabor.getOrgLaborId();
1365
1366 long typeId = orgLabor.getTypeId();
1367 int sunOpen = orgLabor.getSunOpen();
1368 int sunClose = orgLabor.getSunClose();
1369 int monOpen = orgLabor.getMonOpen();
1370 int monClose = orgLabor.getMonClose();
1371 int tueOpen = orgLabor.getTueOpen();
1372 int tueClose = orgLabor.getTueClose();
1373 int wedOpen = orgLabor.getWedOpen();
1374 int wedClose = orgLabor.getWedClose();
1375 int thuOpen = orgLabor.getThuOpen();
1376 int thuClose = orgLabor.getThuClose();
1377 int friOpen = orgLabor.getFriOpen();
1378 int friClose = orgLabor.getFriClose();
1379 int satOpen = orgLabor.getSatOpen();
1380 int satClose = orgLabor.getSatClose();
1381
1382 if (orgLaborId <= 0) {
1383 orgLabor = OrgLaborServiceUtil.addOrgLabor(
1384 classPK, typeId, sunOpen, sunClose, monOpen, monClose,
1385 tueOpen, tueClose, wedOpen, wedClose, thuOpen, thuClose,
1386 friOpen, friClose, satOpen, satClose);
1387
1388 orgLaborId = orgLabor.getOrgLaborId();
1389 }
1390 else {
1391 OrgLaborServiceUtil.updateOrgLabor(
1392 orgLaborId, typeId, sunOpen, sunClose, monOpen, monClose,
1393 tueOpen, tueClose, wedOpen, wedClose, thuOpen, thuClose,
1394 friOpen, friClose, satOpen, satClose);
1395 }
1396
1397 orgLaborsIds.add(orgLaborId);
1398 }
1399
1400 orgLabors = OrgLaborServiceUtil.getOrgLabors(classPK);
1401
1402 for (OrgLabor orgLabor : orgLabors) {
1403 if (!orgLaborsIds.contains(orgLabor.getOrgLaborId())) {
1404 OrgLaborServiceUtil.deleteOrgLabor(orgLabor.getOrgLaborId());
1405 }
1406 }
1407 }
1408
1409 @Override
1410 public void updatePhones(String className, long classPK, List<Phone> phones)
1411 throws PortalException {
1412
1413 Set<Long> phoneIds = new HashSet<>();
1414
1415 for (Phone phone : phones) {
1416 long phoneId = phone.getPhoneId();
1417
1418 String number = phone.getNumber();
1419 String extension = phone.getExtension();
1420 long typeId = phone.getTypeId();
1421 boolean primary = phone.isPrimary();
1422
1423 if (phoneId <= 0) {
1424 phone = PhoneServiceUtil.addPhone(
1425 className, classPK, number, extension, typeId, primary,
1426 new ServiceContext());
1427
1428 phoneId = phone.getPhoneId();
1429 }
1430 else {
1431 PhoneServiceUtil.updatePhone(
1432 phoneId, number, extension, typeId, primary);
1433 }
1434
1435 phoneIds.add(phoneId);
1436 }
1437
1438 phones = PhoneServiceUtil.getPhones(className, classPK);
1439
1440 for (Phone phone : phones) {
1441 if (!phoneIds.contains(phone.getPhoneId())) {
1442 PhoneServiceUtil.deletePhone(phone.getPhoneId());
1443 }
1444 }
1445 }
1446
1447 @Override
1448 public void updateWebsites(
1449 String className, long classPK, List<Website> websites)
1450 throws PortalException {
1451
1452 Set<Long> websiteIds = new HashSet<>();
1453
1454 for (Website website : websites) {
1455 long websiteId = website.getWebsiteId();
1456
1457 String url = website.getUrl();
1458 long typeId = website.getTypeId();
1459 boolean primary = website.isPrimary();
1460
1461 if (websiteId <= 0) {
1462 website = WebsiteServiceUtil.addWebsite(
1463 className, classPK, url, typeId, primary,
1464 new ServiceContext());
1465
1466 websiteId = website.getWebsiteId();
1467 }
1468 else {
1469 WebsiteServiceUtil.updateWebsite(
1470 websiteId, url, typeId, primary);
1471 }
1472
1473 websiteIds.add(websiteId);
1474 }
1475
1476 websites = WebsiteServiceUtil.getWebsites(className, classPK);
1477
1478 for (Website website : websites) {
1479 if (!websiteIds.contains(website.getWebsiteId())) {
1480 WebsiteServiceUtil.deleteWebsite(website.getWebsiteId());
1481 }
1482 }
1483 }
1484
1485 protected long[] getRequestPrimaryKeys(
1486 PortletRequest portletRequest, long[] currentPKs, String addParam,
1487 String deleteParam) {
1488
1489 Set<Long> primaryKeys = SetUtil.fromArray(currentPKs);
1490
1491 long[] addPrimaryKeys = StringUtil.split(
1492 ParamUtil.getString(portletRequest, addParam), 0L);
1493 long[] deletePrimaryKeys = StringUtil.split(
1494 ParamUtil.getString(portletRequest, deleteParam), 0L);
1495
1496 for (long addPrimaryKey : addPrimaryKeys) {
1497 primaryKeys.add(addPrimaryKey);
1498 }
1499
1500 for (long deletePrimaryKey : deletePrimaryKeys) {
1501 primaryKeys.remove(deletePrimaryKey);
1502 }
1503
1504 return ArrayUtil.toLongArray(primaryKeys);
1505 }
1506
1507 protected Set<UserGroupRole> getUserGroupRoles(
1508 PortletRequest portletRequest, User user, String groupIdsParam,
1509 String roleIdsParam) {
1510
1511 Set<UserGroupRole> userGroupRoles = new HashSet<>();
1512
1513 long[] groupRolesGroupIds = StringUtil.split(
1514 ParamUtil.getString(portletRequest, groupIdsParam), 0L);
1515 long[] groupRolesRoleIds = StringUtil.split(
1516 ParamUtil.getString(portletRequest, roleIdsParam), 0L);
1517
1518 if (groupRolesGroupIds.length != groupRolesRoleIds.length) {
1519 return userGroupRoles;
1520 }
1521
1522 long userId = 0;
1523
1524 if (user != null) {
1525 userId = user.getUserId();
1526 }
1527
1528 for (int i = 0; i < groupRolesGroupIds.length; i++) {
1529 if ((groupRolesGroupIds[i] == 0) || (groupRolesRoleIds[i] == 0)) {
1530 continue;
1531 }
1532
1533 UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
1534 userId, groupRolesGroupIds[i], groupRolesRoleIds[i]);
1535
1536 UserGroupRole userGroupRole =
1537 UserGroupRoleLocalServiceUtil.createUserGroupRole(
1538 userGroupRolePK);
1539
1540 userGroupRoles.add(userGroupRole);
1541 }
1542
1543 return userGroupRoles;
1544 }
1545
1546 }