001
014
015 package com.liferay.portal.service.impl;
016
017 import com.liferay.portal.DuplicateOrganizationException;
018 import com.liferay.portal.OrganizationNameException;
019 import com.liferay.portal.OrganizationParentException;
020 import com.liferay.portal.OrganizationTypeException;
021 import com.liferay.portal.RequiredOrganizationException;
022 import com.liferay.portal.kernel.configuration.Filter;
023 import com.liferay.portal.kernel.dao.orm.QueryUtil;
024 import com.liferay.portal.kernel.exception.PortalException;
025 import com.liferay.portal.kernel.exception.SystemException;
026 import com.liferay.portal.kernel.search.BaseModelSearchResult;
027 import com.liferay.portal.kernel.search.Hits;
028 import com.liferay.portal.kernel.search.Indexer;
029 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
030 import com.liferay.portal.kernel.search.QueryConfig;
031 import com.liferay.portal.kernel.search.SearchContext;
032 import com.liferay.portal.kernel.search.SearchException;
033 import com.liferay.portal.kernel.search.Sort;
034 import com.liferay.portal.kernel.systemevent.SystemEvent;
035 import com.liferay.portal.kernel.util.ArrayUtil;
036 import com.liferay.portal.kernel.util.GetterUtil;
037 import com.liferay.portal.kernel.util.ListUtil;
038 import com.liferay.portal.kernel.util.MapUtil;
039 import com.liferay.portal.kernel.util.OrderByComparator;
040 import com.liferay.portal.kernel.util.PropsKeys;
041 import com.liferay.portal.kernel.util.SetUtil;
042 import com.liferay.portal.kernel.util.StringPool;
043 import com.liferay.portal.kernel.util.StringUtil;
044 import com.liferay.portal.kernel.util.TreeModelTasksAdapter;
045 import com.liferay.portal.kernel.util.TreePathUtil;
046 import com.liferay.portal.kernel.util.Validator;
047 import com.liferay.portal.kernel.workflow.WorkflowConstants;
048 import com.liferay.portal.model.Company;
049 import com.liferay.portal.model.Country;
050 import com.liferay.portal.model.Group;
051 import com.liferay.portal.model.GroupConstants;
052 import com.liferay.portal.model.ListTypeConstants;
053 import com.liferay.portal.model.Organization;
054 import com.liferay.portal.model.OrganizationConstants;
055 import com.liferay.portal.model.Region;
056 import com.liferay.portal.model.ResourceConstants;
057 import com.liferay.portal.model.Role;
058 import com.liferay.portal.model.RoleConstants;
059 import com.liferay.portal.model.SystemEventConstants;
060 import com.liferay.portal.model.User;
061 import com.liferay.portal.model.UserGroupRole;
062 import com.liferay.portal.model.impl.OrganizationImpl;
063 import com.liferay.portal.security.permission.PermissionCacheUtil;
064 import com.liferay.portal.service.ServiceContext;
065 import com.liferay.portal.service.base.OrganizationLocalServiceBaseImpl;
066 import com.liferay.portal.util.PortalUtil;
067 import com.liferay.portal.util.PrefsPropsUtil;
068 import com.liferay.portal.util.PropsUtil;
069 import com.liferay.portal.util.PropsValues;
070 import com.liferay.portal.util.comparator.OrganizationIdComparator;
071 import com.liferay.portal.util.comparator.OrganizationNameComparator;
072 import com.liferay.portlet.usersadmin.util.UsersAdminUtil;
073 import com.liferay.util.dao.orm.CustomSQLUtil;
074
075 import java.io.Serializable;
076
077 import java.util.ArrayList;
078 import java.util.Collections;
079 import java.util.HashMap;
080 import java.util.HashSet;
081 import java.util.Iterator;
082 import java.util.LinkedHashMap;
083 import java.util.List;
084 import java.util.Map;
085 import java.util.Set;
086
087
097 public class OrganizationLocalServiceImpl
098 extends OrganizationLocalServiceBaseImpl {
099
100
108 @Override
109 public void addGroupOrganizations(long groupId, long[] organizationIds)
110 throws PortalException {
111
112 groupPersistence.addOrganizations(groupId, organizationIds);
113
114 PermissionCacheUtil.clearCache();
115 }
116
117
138 @Override
139 public Organization addOrganization(
140 long userId, long parentOrganizationId, String name, boolean site)
141 throws PortalException {
142
143 return addOrganization(
144 userId, parentOrganizationId, name,
145 OrganizationConstants.TYPE_REGULAR_ORGANIZATION, 0, 0,
146 ListTypeConstants.ORGANIZATION_STATUS_DEFAULT, StringPool.BLANK,
147 site, null);
148 }
149
150
185 @Deprecated
186 @Override
187 public Organization addOrganization(
188 long userId, long parentOrganizationId, String name, String type,
189 boolean recursable, long regionId, long countryId, long statusId,
190 String comments, boolean site, ServiceContext serviceContext)
191 throws PortalException {
192
193 return addOrganization(
194 userId, parentOrganizationId, name, type, regionId, countryId,
195 statusId, comments, site, serviceContext);
196 }
197
198
227 @Override
228 public Organization addOrganization(
229 long userId, long parentOrganizationId, String name, String type,
230 long regionId, long countryId, long statusId, String comments,
231 boolean site, ServiceContext serviceContext)
232 throws PortalException {
233
234
235
236 User user = userPersistence.findByPrimaryKey(userId);
237 parentOrganizationId = getParentOrganizationId(
238 user.getCompanyId(), parentOrganizationId);
239
240 validate(
241 user.getCompanyId(), parentOrganizationId, name, type, countryId,
242 statusId);
243
244 long organizationId = counterLocalService.increment();
245
246 Organization organization = organizationPersistence.create(
247 organizationId);
248
249 if (serviceContext != null) {
250 organization.setUuid(serviceContext.getUuid());
251 }
252
253 organization.setCompanyId(user.getCompanyId());
254 organization.setUserId(user.getUserId());
255 organization.setUserName(user.getFullName());
256 organization.setParentOrganizationId(parentOrganizationId);
257 organization.setTreePath(organization.buildTreePath());
258 organization.setName(name);
259 organization.setType(type);
260 organization.setRecursable(true);
261 organization.setRegionId(regionId);
262 organization.setCountryId(countryId);
263 organization.setStatusId(statusId);
264 organization.setComments(comments);
265 organization.setExpandoBridgeAttributes(serviceContext);
266
267 organizationPersistence.update(organization);
268
269
270
271 long parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
272
273 if (parentOrganizationId !=
274 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
275
276 Organization parentOrganization =
277 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
278
279 if (parentOrganization != null) {
280 Group parentGroup = parentOrganization.getGroup();
281
282 if (site && parentGroup.isSite()) {
283 parentGroupId = parentOrganization.getGroupId();
284 }
285 }
286 }
287
288 Group group = groupLocalService.addGroup(
289 userId, parentGroupId, Organization.class.getName(), organizationId,
290 GroupConstants.DEFAULT_LIVE_GROUP_ID, getLocalizationMap(name),
291 null, GroupConstants.TYPE_SITE_PRIVATE, false,
292 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, null, site, true,
293 null);
294
295
296
297 Role role = roleLocalService.getRole(
298 organization.getCompanyId(), RoleConstants.ORGANIZATION_OWNER);
299
300 userGroupRoleLocalService.addUserGroupRoles(
301 userId, group.getGroupId(), new long[] {role.getRoleId()});
302
303
304
305 addOrganizationResources(userId, organization);
306
307
308
309 if (serviceContext != null) {
310 updateAsset(
311 userId, organization, serviceContext.getAssetCategoryIds(),
312 serviceContext.getAssetTagNames());
313 }
314
315
316
317 if ((serviceContext == null) || serviceContext.isIndexingEnabled()) {
318 Indexer<Organization> indexer =
319 IndexerRegistryUtil.nullSafeGetIndexer(Organization.class);
320
321 indexer.reindex(organization);
322 }
323
324 return organization;
325 }
326
327
335 @Override
336 public void addOrganizationResources(long userId, Organization organization)
337 throws PortalException {
338
339 String name = Organization.class.getName();
340
341 resourceLocalService.addResources(
342 organization.getCompanyId(), 0, userId, name,
343 organization.getOrganizationId(), false, false, false);
344 }
345
346
353 @Override
354 public void addPasswordPolicyOrganizations(
355 long passwordPolicyId, long[] organizationIds) {
356
357 passwordPolicyRelLocalService.addPasswordPolicyRels(
358 passwordPolicyId, Organization.class.getName(), organizationIds);
359 }
360
361
369 @Override
370 public void deleteLogo(long organizationId) throws PortalException {
371 Organization organization = getOrganization(organizationId);
372
373 PortalUtil.updateImageId(organization, false, null, "logoId", 0, 0, 0);
374 }
375
376
386 @Override
387 public Organization deleteOrganization(long organizationId)
388 throws PortalException {
389
390 Organization organization = organizationPersistence.findByPrimaryKey(
391 organizationId);
392
393 return organizationLocalService.deleteOrganization(organization);
394 }
395
396
405 @Override
406 @SystemEvent(type = SystemEventConstants.TYPE_DELETE)
407 public Organization deleteOrganization(Organization organization)
408 throws PortalException {
409
410 if ((userLocalService.getOrganizationUsersCount(
411 organization.getOrganizationId(),
412 WorkflowConstants.STATUS_APPROVED) > 0) ||
413 (organizationPersistence.countByC_P(
414 organization.getCompanyId(),
415 organization.getOrganizationId()) > 0)) {
416
417 throw new RequiredOrganizationException();
418 }
419
420
421
422 assetEntryLocalService.deleteEntry(
423 Organization.class.getName(), organization.getOrganizationId());
424
425
426
427 addressLocalService.deleteAddresses(
428 organization.getCompanyId(), Organization.class.getName(),
429 organization.getOrganizationId());
430
431
432
433 emailAddressLocalService.deleteEmailAddresses(
434 organization.getCompanyId(), Organization.class.getName(),
435 organization.getOrganizationId());
436
437
438
439 expandoRowLocalService.deleteRows(organization.getOrganizationId());
440
441
442
443 passwordPolicyRelLocalService.deletePasswordPolicyRel(
444 Organization.class.getName(), organization.getOrganizationId());
445
446
447
448 phoneLocalService.deletePhones(
449 organization.getCompanyId(), Organization.class.getName(),
450 organization.getOrganizationId());
451
452
453
454 websiteLocalService.deleteWebsites(
455 organization.getCompanyId(), Organization.class.getName(),
456 organization.getOrganizationId());
457
458
459
460 Group group = organization.getGroup();
461
462 if (group.isSite()) {
463 group.setSite(false);
464
465 groupPersistence.update(group);
466 }
467
468 groupLocalService.deleteGroup(group);
469
470
471
472 String name = Organization.class.getName();
473
474 resourceLocalService.deleteResource(
475 organization.getCompanyId(), name,
476 ResourceConstants.SCOPE_INDIVIDUAL,
477 organization.getOrganizationId());
478
479
480
481 organizationPersistence.remove(organization);
482
483
484
485 PermissionCacheUtil.clearCache();
486
487 return organization;
488 }
489
490
498 @Override
499 public Organization fetchOrganization(long companyId, String name) {
500 return organizationPersistence.fetchByC_N(companyId, name);
501 }
502
503 @Override
504 public List<Organization> getGroupUserOrganizations(
505 long groupId, long userId)
506 throws PortalException {
507
508 long[] groupOrganizationIds =
509 groupPersistence.getOrganizationPrimaryKeys(groupId);
510
511 if (groupOrganizationIds.length == 0) {
512 return Collections.emptyList();
513 }
514
515 long[] userOrganizationIds = userPersistence.getOrganizationPrimaryKeys(
516 userId);
517
518 if (userOrganizationIds.length == 0) {
519 return Collections.emptyList();
520 }
521
522 Set<Long> organizationIds = SetUtil.intersect(
523 groupOrganizationIds, userOrganizationIds);
524
525 if (organizationIds.isEmpty()) {
526 return Collections.emptyList();
527 }
528
529 List<Organization> organizations = new ArrayList<>(
530 organizationIds.size());
531
532 for (Long organizationId : organizationIds) {
533 organizations.add(
534 organizationPersistence.findByPrimaryKey(organizationId));
535 }
536
537 return organizations;
538 }
539
540 @Override
541 public List<Organization> getNoAssetOrganizations() {
542 return organizationFinder.findByNoAssets();
543 }
544
545
554 @Override
555 public Organization getOrganization(long companyId, String name)
556 throws PortalException {
557
558 return organizationPersistence.findByC_N(companyId, name);
559 }
560
561
569 @Override
570 public long getOrganizationId(long companyId, String name) {
571 Organization organization = organizationPersistence.fetchByC_N(
572 companyId, name);
573
574 if (organization != null) {
575 return organization.getOrganizationId();
576 }
577 else {
578 return 0;
579 }
580 }
581
582 @Override
583 public List<Organization> getOrganizations(
584 long userId, int start, int end,
585 OrderByComparator<Organization> obc)
586 throws PortalException {
587
588 User user = userPersistence.findByPrimaryKey(userId);
589
590 List<Organization> organizations = ListUtil.copy(
591 userPersistence.getOrganizations(userId));
592
593 Iterator<Organization> iterator = organizations.iterator();
594
595 while (iterator.hasNext()) {
596 Organization organization = iterator.next();
597
598 if (organization.getCompanyId() != user.getCompanyId()) {
599 iterator.remove();
600 }
601 }
602
603 if (organizations.isEmpty()) {
604 return organizations;
605 }
606
607 if (obc == null) {
608 obc = new OrganizationNameComparator(true);
609 }
610
611 Collections.sort(organizations, obc);
612
613 return ListUtil.subList(organizations, start, end);
614 }
615
616
624 @Override
625 public List<Organization> getOrganizations(
626 long companyId, long parentOrganizationId) {
627
628 return getOrganizations(
629 companyId, parentOrganizationId, QueryUtil.ALL_POS,
630 QueryUtil.ALL_POS);
631 }
632
633
656 @Override
657 public List<Organization> getOrganizations(
658 long companyId, long parentOrganizationId, int start, int end) {
659
660 if (parentOrganizationId ==
661 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
662
663 return organizationPersistence.findByCompanyId(
664 companyId, start, end);
665 }
666 else {
667 return organizationPersistence.findByC_P(
668 companyId, parentOrganizationId, start, end);
669 }
670 }
671
672
680 @Override
681 public List<Organization> getOrganizations(long[] organizationIds)
682 throws PortalException {
683
684 List<Organization> organizations = new ArrayList<>(
685 organizationIds.length);
686
687 for (long organizationId : organizationIds) {
688 Organization organization = getOrganization(organizationId);
689
690 organizations.add(organization);
691 }
692
693 return organizations;
694 }
695
696
704 @Override
705 public int getOrganizationsCount(
706 long companyId, long parentOrganizationId) {
707
708 if (parentOrganizationId ==
709 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
710
711 return organizationPersistence.countByCompanyId(companyId);
712 }
713 else {
714 return organizationPersistence.countByC_P(
715 companyId, parentOrganizationId);
716 }
717 }
718
719
728 @Override
729 public List<Organization> getParentOrganizations(long organizationId)
730 throws PortalException {
731
732 if (organizationId ==
733 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
734
735 return new ArrayList<>();
736 }
737
738 Organization organization = organizationPersistence.findByPrimaryKey(
739 organizationId);
740
741 return organization.getAncestors();
742 }
743
744
751 @Override
752 public List<Organization> getSuborganizations(
753 List<Organization> organizations) {
754
755 List<Organization> allSuborganizations = new ArrayList<>();
756
757 for (int i = 0; i < organizations.size(); i++) {
758 Organization organization = organizations.get(i);
759
760 List<Organization> suborganizations =
761 organizationPersistence.findByC_P(
762 organization.getCompanyId(),
763 organization.getOrganizationId());
764
765 addSuborganizations(allSuborganizations, suborganizations);
766 }
767
768 return allSuborganizations;
769 }
770
771
778 @Override
779 public List<Organization> getSuborganizations(
780 long companyId, long organizationId) {
781
782 return organizationPersistence.findByC_P(companyId, organizationId);
783 }
784
785
792 @Override
793 public int getSuborganizationsCount(long companyId, long organizationId) {
794 return organizationPersistence.countByC_P(companyId, organizationId);
795 }
796
797
806 @Override
807 public List<Organization> getSubsetOrganizations(
808 List<Organization> allOrganizations,
809 List<Organization> availableOrganizations) {
810
811 List<Organization> subsetOrganizations = new ArrayList<>();
812
813 for (Organization organization : allOrganizations) {
814 if (availableOrganizations.contains(organization)) {
815 subsetOrganizations.add(organization);
816 }
817 }
818
819 return subsetOrganizations;
820 }
821
822
843 @Override
844 public long[] getUserOrganizationIds(
845 long userId, boolean includeAdministrative)
846 throws PortalException {
847
848 if (!includeAdministrative) {
849 return userPersistence.getOrganizationPrimaryKeys(userId);
850 }
851
852 Set<Long> organizationIds = SetUtil.fromArray(
853 userPersistence.getOrganizationPrimaryKeys(userId));
854
855 List<UserGroupRole> userGroupRoles =
856 userGroupRoleLocalService.getUserGroupRoles(userId);
857
858 for (UserGroupRole userGroupRole : userGroupRoles) {
859 Role role = userGroupRole.getRole();
860
861 String roleName = role.getName();
862
863 if (roleName.equals(RoleConstants.ORGANIZATION_ADMINISTRATOR) ||
864 roleName.equals(RoleConstants.ORGANIZATION_OWNER)) {
865
866 Group group = userGroupRole.getGroup();
867
868 organizationIds.add(group.getOrganizationId());
869 }
870 }
871
872 return ArrayUtil.toLongArray(organizationIds);
873 }
874
875
895 @Override
896 public List<Organization> getUserOrganizations(
897 long userId, boolean includeAdministrative)
898 throws PortalException {
899
900 if (!includeAdministrative) {
901 return getUserOrganizations(userId);
902 }
903
904 Set<Organization> organizations = new HashSet<>(
905 getUserOrganizations(userId));
906
907 List<UserGroupRole> userGroupRoles =
908 userGroupRoleLocalService.getUserGroupRoles(userId);
909
910 for (UserGroupRole userGroupRole : userGroupRoles) {
911 Role role = userGroupRole.getRole();
912
913 String roleName = role.getName();
914
915 if (roleName.equals(RoleConstants.ORGANIZATION_ADMINISTRATOR) ||
916 roleName.equals(RoleConstants.ORGANIZATION_OWNER)) {
917
918 Group group = userGroupRole.getGroup();
919
920 Organization organization =
921 organizationPersistence.findByPrimaryKey(
922 group.getOrganizationId());
923
924 organizations.add(organization);
925 }
926 }
927
928 return new ArrayList<>(organizations);
929 }
930
931
940 @Override
941 public boolean hasPasswordPolicyOrganization(
942 long passwordPolicyId, long organizationId) {
943
944 return passwordPolicyRelLocalService.hasPasswordPolicyRel(
945 passwordPolicyId, Organization.class.getName(), organizationId);
946 }
947
948
996 @Override
997 public boolean hasUserOrganization(
998 long userId, long organizationId, boolean inheritSuborganizations,
999 boolean includeSpecifiedOrganization)
1000 throws PortalException {
1001
1002 if (!inheritSuborganizations) {
1003 return userPersistence.containsOrganization(userId, organizationId);
1004 }
1005
1006 LinkedHashMap<String, Object> params = new LinkedHashMap<>();
1007
1008 List<Organization> organizationsTree = new ArrayList<>();
1009
1010 Organization organization = organizationPersistence.findByPrimaryKey(
1011 organizationId);
1012
1013 if (!includeSpecifiedOrganization) {
1014 organizationsTree.add(organization);
1015 }
1016 else {
1017 organizationsTree.add(organization.getParentOrganization());
1018 }
1019
1020 params.put("usersOrgsTree", organizationsTree);
1021
1022 if (userFinder.countByUser(userId, params) > 0) {
1023 return true;
1024 }
1025
1026 return false;
1027 }
1028
1029
1042 @Override
1043 public void rebuildTree(long companyId) throws PortalException {
1044 TreePathUtil.rebuildTree(
1045 companyId, OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID,
1046 StringPool.SLASH,
1047 new TreeModelTasksAdapter<Organization>() {
1048
1049 @Override
1050 public List<Organization> findTreeModels(
1051 long previousId, long companyId, long parentPrimaryKey,
1052 int size) {
1053
1054 return organizationPersistence.findByO_C_P(
1055 previousId, companyId, parentPrimaryKey,
1056 QueryUtil.ALL_POS, size,
1057 new OrganizationIdComparator(true));
1058 }
1059
1060 }
1061 );
1062 }
1063
1064
1095 @Override
1096 public Hits search(
1097 long companyId, long parentOrganizationId, String keywords,
1098 LinkedHashMap<String, Object> params, int start, int end, Sort sort) {
1099
1100 String name = null;
1101 String type = null;
1102 String street = null;
1103 String city = null;
1104 String zip = null;
1105 String region = null;
1106 String country = null;
1107 boolean andOperator = false;
1108
1109 if (Validator.isNotNull(keywords)) {
1110 name = keywords;
1111 type = keywords;
1112 street = keywords;
1113 city = keywords;
1114 zip = keywords;
1115 region = keywords;
1116 country = keywords;
1117 }
1118 else {
1119 andOperator = true;
1120 }
1121
1122 if (params != null) {
1123 params.put("keywords", keywords);
1124 }
1125
1126 return search(
1127 companyId, parentOrganizationId, name, type, street, city, zip,
1128 region, country, params, andOperator, start, end, sort);
1129 }
1130
1131
1166 @Override
1167 public List<Organization> search(
1168 long companyId, long parentOrganizationId, String keywords, String type,
1169 Long regionId, Long countryId, LinkedHashMap<String, Object> params,
1170 int start, int end) {
1171
1172 return search(
1173 companyId, parentOrganizationId, keywords, type, regionId,
1174 countryId, params, start, end,
1175 new OrganizationNameComparator(true));
1176 }
1177
1178
1216 @Override
1217 public List<Organization> search(
1218 long companyId, long parentOrganizationId, String keywords, String type,
1219 Long regionId, Long countryId, LinkedHashMap<String, Object> params,
1220 int start, int end, OrderByComparator<Organization> obc) {
1221
1222 String parentOrganizationIdComparator = StringPool.EQUAL;
1223
1224 if (parentOrganizationId ==
1225 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1226
1227 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1228 }
1229
1230 return organizationFinder.findByKeywords(
1231 companyId, parentOrganizationId, parentOrganizationIdComparator,
1232 keywords, type, regionId, countryId, params, start, end, obc);
1233 }
1234
1235
1277 @Override
1278 public List<Organization> search(
1279 long companyId, long parentOrganizationId, String name, String type,
1280 String street, String city, String zip, Long regionId, Long countryId,
1281 LinkedHashMap<String, Object> params, boolean andOperator, int start,
1282 int end) {
1283
1284 return search(
1285 companyId, parentOrganizationId, name, type, street, city, zip,
1286 regionId, countryId, params, andOperator, start, end,
1287 new OrganizationNameComparator(true));
1288 }
1289
1290
1335 @Override
1336 public List<Organization> search(
1337 long companyId, long parentOrganizationId, String name, String type,
1338 String street, String city, String zip, Long regionId, Long countryId,
1339 LinkedHashMap<String, Object> params, boolean andOperator, int start,
1340 int end, OrderByComparator<Organization> obc) {
1341
1342 String parentOrganizationIdComparator = StringPool.EQUAL;
1343
1344 if (parentOrganizationId ==
1345 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1346
1347 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1348 }
1349
1350 return organizationFinder.findByC_PO_N_T_S_C_Z_R_C(
1351 companyId, parentOrganizationId, parentOrganizationIdComparator,
1352 name, type, street, city, zip, regionId, countryId, params,
1353 andOperator, start, end, obc);
1354 }
1355
1356
1395 @Override
1396 public Hits search(
1397 long companyId, long parentOrganizationId, String name, String type,
1398 String street, String city, String zip, String region, String country,
1399 LinkedHashMap<String, Object> params, boolean andSearch, int start,
1400 int end, Sort sort) {
1401
1402 try {
1403 Indexer<Organization> indexer =
1404 IndexerRegistryUtil.nullSafeGetIndexer(Organization.class);
1405
1406 SearchContext searchContext = buildSearchContext(
1407 companyId, parentOrganizationId, name, type, street, city, zip,
1408 region, country, params, andSearch, start, end, sort);
1409
1410 return indexer.search(searchContext);
1411 }
1412 catch (Exception e) {
1413 throw new SystemException(e);
1414 }
1415 }
1416
1417
1438 @Override
1439 public int searchCount(
1440 long companyId, long parentOrganizationId, String keywords, String type,
1441 Long regionId, Long countryId, LinkedHashMap<String, Object> params) {
1442
1443 Indexer<?> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1444 Organization.class);
1445
1446 if (!indexer.isIndexerEnabled() ||
1447 !PropsValues.ORGANIZATIONS_SEARCH_WITH_INDEX ||
1448 isUseCustomSQL(params)) {
1449
1450 String parentOrganizationIdComparator = StringPool.EQUAL;
1451
1452 if (parentOrganizationId ==
1453 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1454
1455 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1456 }
1457
1458 return organizationFinder.countByKeywords(
1459 companyId, parentOrganizationId, parentOrganizationIdComparator,
1460 keywords, type, regionId, countryId, params);
1461 }
1462
1463 try {
1464 String name = null;
1465 String street = null;
1466 String city = null;
1467 String zip = null;
1468 boolean andOperator = false;
1469
1470 if (Validator.isNotNull(keywords)) {
1471 name = keywords;
1472 street = keywords;
1473 city = keywords;
1474 zip = keywords;
1475 }
1476 else {
1477 andOperator = true;
1478 }
1479
1480 if (params != null) {
1481 params.put("keywords", keywords);
1482 }
1483
1484 SearchContext searchContext = buildSearchContext(
1485 companyId, parentOrganizationId, name, type, street, city, zip,
1486 regionId, countryId, params, andOperator, QueryUtil.ALL_POS,
1487 QueryUtil.ALL_POS, null);
1488
1489 return (int)indexer.searchCount(searchContext);
1490 }
1491 catch (Exception e) {
1492 throw new SystemException(e);
1493 }
1494 }
1495
1496
1524 @Override
1525 public int searchCount(
1526 long companyId, long parentOrganizationId, String name, String type,
1527 String street, String city, String zip, Long regionId, Long countryId,
1528 LinkedHashMap<String, Object> params, boolean andOperator) {
1529
1530 Indexer<?> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1531 Organization.class);
1532
1533 if (!indexer.isIndexerEnabled() ||
1534 !PropsValues.ORGANIZATIONS_SEARCH_WITH_INDEX ||
1535 isUseCustomSQL(params)) {
1536
1537 String parentOrganizationIdComparator = StringPool.EQUAL;
1538
1539 if (parentOrganizationId ==
1540 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1541
1542 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1543 }
1544
1545 return organizationFinder.countByC_PO_N_T_S_C_Z_R_C(
1546 companyId, parentOrganizationId, parentOrganizationIdComparator,
1547 name, type, street, city, zip, regionId, countryId, params,
1548 andOperator);
1549 }
1550
1551 try {
1552 SearchContext searchContext = buildSearchContext(
1553 companyId, parentOrganizationId, name, type, street, city, zip,
1554 regionId, countryId, params, andOperator, QueryUtil.ALL_POS,
1555 QueryUtil.ALL_POS, null);
1556
1557 return (int)indexer.searchCount(searchContext);
1558 }
1559 catch (Exception e) {
1560 throw new SystemException(e);
1561 }
1562 }
1563
1564 @Override
1565 public BaseModelSearchResult<Organization> searchOrganizations(
1566 long companyId, long parentOrganizationId, String keywords,
1567 LinkedHashMap<String, Object> params, int start, int end, Sort sort)
1568 throws PortalException {
1569
1570 String name = null;
1571 String type = null;
1572 String street = null;
1573 String city = null;
1574 String zip = null;
1575 String region = null;
1576 String country = null;
1577 boolean andOperator = false;
1578
1579 if (Validator.isNotNull(keywords)) {
1580 name = keywords;
1581 type = keywords;
1582 street = keywords;
1583 city = keywords;
1584 zip = keywords;
1585 region = keywords;
1586 country = keywords;
1587 }
1588 else {
1589 andOperator = true;
1590 }
1591
1592 if (params != null) {
1593 params.put("keywords", keywords);
1594 }
1595
1596 return searchOrganizations(
1597 companyId, parentOrganizationId, name, type, street, city, zip,
1598 region, country, params, andOperator, start, end, sort);
1599 }
1600
1601 @Override
1602 public BaseModelSearchResult<Organization> searchOrganizations(
1603 long companyId, long parentOrganizationId, String name, String type,
1604 String street, String city, String zip, String region,
1605 String country, LinkedHashMap<String, Object> params,
1606 boolean andSearch, int start, int end, Sort sort)
1607 throws PortalException {
1608
1609 Indexer<Organization> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1610 Organization.class);
1611
1612 SearchContext searchContext = buildSearchContext(
1613 companyId, parentOrganizationId, name, type, street, city, zip,
1614 region, country, params, andSearch, start, end, sort);
1615
1616 for (int i = 0; i < 10; i++) {
1617 Hits hits = indexer.search(searchContext);
1618
1619 List<Organization> organizations = UsersAdminUtil.getOrganizations(
1620 hits);
1621
1622 if (organizations != null) {
1623 return new BaseModelSearchResult<>(
1624 organizations, hits.getLength());
1625 }
1626 }
1627
1628 throw new SearchException(
1629 "Unable to fix the search index after 10 attempts");
1630 }
1631
1632
1640 @Override
1641 public void setGroupOrganizations(long groupId, long[] organizationIds)
1642 throws PortalException {
1643
1644 groupPersistence.setOrganizations(groupId, organizationIds);
1645
1646 PermissionCacheUtil.clearCache();
1647 }
1648
1649
1656 @Override
1657 public void unsetGroupOrganizations(long groupId, long[] organizationIds)
1658 throws PortalException {
1659
1660 groupPersistence.removeOrganizations(groupId, organizationIds);
1661
1662 PermissionCacheUtil.clearCache();
1663 }
1664
1665
1671 @Override
1672 public void unsetPasswordPolicyOrganizations(
1673 long passwordPolicyId, long[] organizationIds) {
1674
1675 passwordPolicyRelLocalService.deletePasswordPolicyRels(
1676 passwordPolicyId, Organization.class.getName(), organizationIds);
1677 }
1678
1679
1689 @Override
1690 public void updateAsset(
1691 long userId, Organization organization, long[] assetCategoryIds,
1692 String[] assetTagNames)
1693 throws PortalException {
1694
1695 User user = userPersistence.findByPrimaryKey(userId);
1696
1697 Company company = companyPersistence.findByPrimaryKey(
1698 user.getCompanyId());
1699
1700 Group companyGroup = company.getGroup();
1701
1702 assetEntryLocalService.updateEntry(
1703 userId, companyGroup.getGroupId(), null, null,
1704 Organization.class.getName(), organization.getOrganizationId(),
1705 organization.getUuid(), 0, assetCategoryIds, assetTagNames, false,
1706 null, null, null, null, organization.getName(), StringPool.BLANK,
1707 null, null, null, 0, 0, null);
1708 }
1709
1710
1739 @Deprecated
1740 @Override
1741 public Organization updateOrganization(
1742 long companyId, long organizationId, long parentOrganizationId,
1743 String name, String type, boolean recursable, long regionId,
1744 long countryId, long statusId, String comments, boolean site,
1745 ServiceContext serviceContext)
1746 throws PortalException {
1747
1748 return updateOrganization(
1749 companyId, organizationId, parentOrganizationId, name, type,
1750 regionId, countryId, statusId, comments, true, null, site,
1751 serviceContext);
1752 }
1753
1754
1780 @Override
1781 public Organization updateOrganization(
1782 long companyId, long organizationId, long parentOrganizationId,
1783 String name, String type, long regionId, long countryId,
1784 long statusId, String comments, boolean logo, byte[] logoBytes,
1785 boolean site, ServiceContext serviceContext)
1786 throws PortalException {
1787
1788
1789
1790 parentOrganizationId = getParentOrganizationId(
1791 companyId, parentOrganizationId);
1792
1793 validate(
1794 companyId, organizationId, parentOrganizationId, name, type,
1795 countryId, statusId);
1796
1797 Organization organization = organizationPersistence.findByPrimaryKey(
1798 organizationId);
1799
1800 long oldParentOrganizationId = organization.getParentOrganizationId();
1801 String oldName = organization.getName();
1802
1803 organization.setParentOrganizationId(parentOrganizationId);
1804 organization.setTreePath(organization.buildTreePath());
1805 organization.setName(name);
1806 organization.setType(type);
1807 organization.setRecursable(true);
1808 organization.setRegionId(regionId);
1809 organization.setCountryId(countryId);
1810 organization.setStatusId(statusId);
1811 organization.setComments(comments);
1812
1813 PortalUtil.updateImageId(
1814 organization, logo, logoBytes, "logoId",
1815 PrefsPropsUtil.getLong(PropsKeys.USERS_IMAGE_MAX_SIZE),
1816 PropsValues.USERS_IMAGE_MAX_HEIGHT,
1817 PropsValues.USERS_IMAGE_MAX_WIDTH);
1818
1819 organization.setExpandoBridgeAttributes(serviceContext);
1820
1821 organizationPersistence.update(organization);
1822
1823
1824
1825 Group group = organization.getGroup();
1826
1827 long parentGroupId = group.getParentGroupId();
1828
1829 boolean createSite = false;
1830
1831 if (!group.isSite() && site) {
1832 createSite = true;
1833 }
1834
1835 boolean organizationGroup = isOrganizationGroup(
1836 oldParentOrganizationId, group.getParentGroupId());
1837
1838 if (createSite || organizationGroup) {
1839 if (parentOrganizationId !=
1840 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1841
1842 Organization parentOrganization =
1843 organizationPersistence.fetchByPrimaryKey(
1844 parentOrganizationId);
1845
1846 Group parentGroup = parentOrganization.getGroup();
1847
1848 if (site && parentGroup.isSite()) {
1849 parentGroupId = parentOrganization.getGroupId();
1850 }
1851 else {
1852 parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
1853 }
1854 }
1855 else {
1856 parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
1857 }
1858 }
1859
1860 if (createSite || !oldName.equals(name) || organizationGroup) {
1861 groupLocalService.updateGroup(
1862 group.getGroupId(), parentGroupId, getLocalizationMap(name),
1863 group.getDescriptionMap(), group.getType(),
1864 group.isManualMembership(), group.getMembershipRestriction(),
1865 group.getFriendlyURL(), group.isInheritContent(),
1866 group.isActive(), null);
1867 }
1868
1869 if (group.isSite() != site) {
1870 groupLocalService.updateSite(group.getGroupId(), site);
1871 }
1872
1873
1874
1875 if (createSite) {
1876 List<Organization> childOrganizations =
1877 organizationLocalService.getOrganizations(
1878 companyId, organizationId);
1879
1880 for (Organization childOrganization : childOrganizations) {
1881 Group childGroup = childOrganization.getGroup();
1882
1883 if (childGroup.isSite() &&
1884 (childGroup.getParentGroupId() ==
1885 GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
1886
1887 childGroup.setParentGroupId(group.getGroupId());
1888
1889 groupLocalService.updateGroup(childGroup);
1890 }
1891 }
1892 }
1893
1894
1895
1896 if (serviceContext != null) {
1897 updateAsset(
1898 serviceContext.getUserId(), organization,
1899 serviceContext.getAssetCategoryIds(),
1900 serviceContext.getAssetTagNames());
1901 }
1902
1903
1904
1905 Indexer<Organization> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1906 Organization.class);
1907
1908 if (oldParentOrganizationId != parentOrganizationId) {
1909 long[] reindexOrganizationIds = getReindexOrganizationIds(
1910 organization);
1911
1912 List<Organization> reindexOrganizations = new ArrayList<>(
1913 reindexOrganizationIds.length);
1914
1915 for (long reindexOrganizationId : reindexOrganizationIds) {
1916 Organization reindexOrganization = fetchOrganization(
1917 reindexOrganizationId);
1918
1919 reindexOrganizations.add(reindexOrganization);
1920 }
1921
1922 indexer.reindex(reindexOrganizations);
1923 }
1924 else {
1925 indexer.reindex(organization);
1926 }
1927
1928 return organization;
1929 }
1930
1931
1958 @Deprecated
1959 @Override
1960 public Organization updateOrganization(
1961 long companyId, long organizationId, long parentOrganizationId,
1962 String name, String type, long regionId, long countryId,
1963 long statusId, String comments, boolean site,
1964 ServiceContext serviceContext)
1965 throws PortalException {
1966
1967 return updateOrganization(
1968 companyId, organizationId, parentOrganizationId, name, type,
1969 regionId, countryId, statusId, comments, site, serviceContext);
1970 }
1971
1972 protected void addSuborganizations(
1973 List<Organization> allSuborganizations,
1974 List<Organization> organizations) {
1975
1976 for (Organization organization : organizations) {
1977 if (!allSuborganizations.contains(organization)) {
1978 allSuborganizations.add(organization);
1979
1980 List<Organization> suborganizations =
1981 organizationPersistence.findByC_P(
1982 organization.getCompanyId(),
1983 organization.getOrganizationId());
1984
1985 addSuborganizations(allSuborganizations, suborganizations);
1986 }
1987 }
1988 }
1989
1990 protected SearchContext buildSearchContext(
1991 long companyId, long parentOrganizationId, String name, String type,
1992 String street, String city, String zip, Long regionId, Long countryId,
1993 LinkedHashMap<String, Object> params, boolean andSearch, int start,
1994 int end, Sort sort) {
1995
1996 String regionCode = null;
1997
1998 if (regionId != null) {
1999 Region region = regionService.fetchRegion(regionId);
2000
2001 regionCode = region.getRegionCode();
2002 }
2003
2004 String countryName = null;
2005
2006 if (countryId != null) {
2007 Country country = countryService.fetchCountry(countryId);
2008
2009 countryName = country.getName();
2010 }
2011
2012 return buildSearchContext(
2013 companyId, parentOrganizationId, name, type, street, city, zip,
2014 regionCode, countryName, params, andSearch, start, end, sort);
2015 }
2016
2017 protected SearchContext buildSearchContext(
2018 long companyId, long parentOrganizationId, String name, String type,
2019 String street, String city, String zip, String region, String country,
2020 LinkedHashMap<String, Object> params, boolean andSearch, int start,
2021 int end, Sort sort) {
2022
2023 SearchContext searchContext = new SearchContext();
2024
2025 searchContext.setAndSearch(andSearch);
2026
2027 Map<String, Serializable> attributes = new HashMap<>();
2028
2029 attributes.put("city", city);
2030 attributes.put("country", country);
2031 attributes.put("name", name);
2032 attributes.put("params", params);
2033 attributes.put(
2034 "parentOrganizationId", String.valueOf(parentOrganizationId));
2035 attributes.put("region", region);
2036 attributes.put("street", street);
2037 attributes.put("type", type);
2038 attributes.put("zip", zip);
2039
2040 searchContext.setAttributes(attributes);
2041
2042 searchContext.setCompanyId(companyId);
2043 searchContext.setEnd(end);
2044
2045 if (params != null) {
2046 String keywords = (String)params.remove("keywords");
2047
2048 if (Validator.isNotNull(keywords)) {
2049 searchContext.setKeywords(keywords);
2050 }
2051 }
2052
2053 if (sort != null) {
2054 searchContext.setSorts(sort);
2055 }
2056
2057 searchContext.setStart(start);
2058
2059 QueryConfig queryConfig = searchContext.getQueryConfig();
2060
2061 queryConfig.setHighlightEnabled(false);
2062 queryConfig.setScoreEnabled(false);
2063
2064 return searchContext;
2065 }
2066
2067 protected long getParentOrganizationId(
2068 long companyId, long parentOrganizationId) {
2069
2070 if (parentOrganizationId !=
2071 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
2072
2073
2074
2075
2076 Organization parentOrganization =
2077 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
2078
2079 if ((parentOrganization == null) ||
2080 (companyId != parentOrganization.getCompanyId())) {
2081
2082 parentOrganizationId =
2083 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID;
2084 }
2085 }
2086
2087 return parentOrganizationId;
2088 }
2089
2090 protected long[] getReindexOrganizationIds(Organization organization)
2091 throws PortalException {
2092
2093 List<Organization> organizations = organizationPersistence.findByC_T(
2094 organization.getCompanyId(),
2095 CustomSQLUtil.keywords(organization.getTreePath())[0],
2096 QueryUtil.ALL_POS, QueryUtil.ALL_POS,
2097 new OrganizationNameComparator(true));
2098
2099 long[] organizationIds = new long[organizations.size()];
2100
2101 for (int i = 0; i < organizations.size(); i++) {
2102 Organization curOrganization = organizations.get(i);
2103
2104 curOrganization.setTreePath(curOrganization.buildTreePath());
2105
2106 organizationPersistence.update(curOrganization);
2107
2108 organizationIds[i] = curOrganization.getOrganizationId();
2109 }
2110
2111 if (!ArrayUtil.contains(
2112 organizationIds, organization.getOrganizationId())) {
2113
2114 organizationIds = ArrayUtil.append(
2115 organizationIds, organization.getOrganizationId());
2116 }
2117
2118 return organizationIds;
2119 }
2120
2121 protected boolean isOrganizationGroup(long organizationId, long groupId) {
2122 if ((organizationId ==
2123 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) &&
2124 (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
2125
2126 return true;
2127 }
2128
2129 if (organizationId !=
2130 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
2131
2132 Organization organization =
2133 organizationPersistence.fetchByPrimaryKey(organizationId);
2134
2135 if (organization.getGroupId() == groupId) {
2136 return true;
2137 }
2138 }
2139
2140 return false;
2141 }
2142
2143 protected boolean isParentOrganization(
2144 long parentOrganizationId, long organizationId)
2145 throws PortalException {
2146
2147
2148
2149
2150 if (organizationId ==
2151 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
2152
2153 return false;
2154 }
2155
2156 Organization organization = organizationPersistence.findByPrimaryKey(
2157 organizationId);
2158
2159 String treePath = organization.getTreePath();
2160
2161 if (treePath.contains(
2162 StringPool.SLASH + parentOrganizationId + StringPool.SLASH)) {
2163
2164 return true;
2165 }
2166 else {
2167 return false;
2168 }
2169 }
2170
2171 protected boolean isUseCustomSQL(LinkedHashMap<String, Object> params) {
2172 if (MapUtil.isEmpty(params)) {
2173 return false;
2174 }
2175
2176 return true;
2177 }
2178
2179 protected void validate(
2180 long companyId, long organizationId, long parentOrganizationId,
2181 String name, String type, long countryId, long statusId)
2182 throws PortalException {
2183
2184 if (!ArrayUtil.contains(PropsValues.ORGANIZATIONS_TYPES, type)) {
2185 throw new OrganizationTypeException(
2186 "Invalid organization type " + type);
2187 }
2188
2189 if (parentOrganizationId ==
2190 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
2191
2192 if (!OrganizationImpl.isRootable(type)) {
2193 throw new OrganizationParentException(
2194 "Organization of type " + type + " cannot be a root");
2195 }
2196 }
2197 else {
2198 Organization parentOrganization =
2199 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
2200
2201 if (parentOrganization == null) {
2202 throw new OrganizationParentException(
2203 "Organization " + parentOrganizationId + " doesn't exist");
2204 }
2205
2206 String[] childrenTypes = OrganizationImpl.getChildrenTypes(
2207 parentOrganization.getType());
2208
2209 if (childrenTypes.length == 0) {
2210 throw new OrganizationParentException(
2211 "Organization of type " + type + " cannot have children");
2212 }
2213
2214 if ((companyId != parentOrganization.getCompanyId()) ||
2215 (parentOrganizationId == organizationId)) {
2216
2217 throw new OrganizationParentException();
2218 }
2219
2220 if (!ArrayUtil.contains(childrenTypes, type)) {
2221 throw new OrganizationParentException(
2222 "Type " + type + " not allowed as child of " +
2223 parentOrganization.getType());
2224 }
2225 }
2226
2227 if ((organizationId > 0) &&
2228 (parentOrganizationId !=
2229 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID)) {
2230
2231
2232
2233 if (isParentOrganization(organizationId, parentOrganizationId)) {
2234 throw new OrganizationParentException();
2235 }
2236 }
2237
2238 if (Validator.isNull(name)) {
2239 throw new OrganizationNameException();
2240 }
2241 else {
2242 Organization organization = organizationPersistence.fetchByC_N(
2243 companyId, name);
2244
2245 if ((organization != null) &&
2246 StringUtil.equalsIgnoreCase(organization.getName(), name)) {
2247
2248 if ((organizationId <= 0) ||
2249 (organization.getOrganizationId() != organizationId)) {
2250
2251 throw new DuplicateOrganizationException(
2252 "There is another organization named " + name);
2253 }
2254 }
2255 }
2256
2257 boolean countryRequired = GetterUtil.getBoolean(
2258 PropsUtil.get(
2259 PropsKeys.ORGANIZATIONS_COUNTRY_REQUIRED, new Filter(type)));
2260
2261 if (countryRequired || (countryId > 0)) {
2262 countryPersistence.findByPrimaryKey(countryId);
2263 }
2264
2265 listTypeService.validate(
2266 statusId, ListTypeConstants.ORGANIZATION_STATUS);
2267 }
2268
2269 protected void validate(
2270 long companyId, long parentOrganizationId, String name, String type,
2271 long countryId, long statusId)
2272 throws PortalException {
2273
2274 validate(
2275 companyId, 0, parentOrganizationId, name, type, countryId,
2276 statusId);
2277 }
2278
2279 }