001
014
015 package com.liferay.portal.service.impl;
016
017 import com.liferay.portal.exception.DuplicateOrganizationException;
018 import com.liferay.portal.exception.OrganizationNameException;
019 import com.liferay.portal.exception.OrganizationParentException;
020 import com.liferay.portal.exception.OrganizationTypeException;
021 import com.liferay.portal.exception.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.users.admin.kernel.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
106 @Override
107 public void addGroupOrganizations(long groupId, long[] organizationIds) {
108 groupPersistence.addOrganizations(groupId, organizationIds);
109
110 PermissionCacheUtil.clearCache();
111 }
112
113
131 @Override
132 public Organization addOrganization(
133 long userId, long parentOrganizationId, String name, boolean site)
134 throws PortalException {
135
136 return addOrganization(
137 userId, parentOrganizationId, name,
138 OrganizationConstants.TYPE_REGULAR_ORGANIZATION, 0, 0,
139 ListTypeConstants.ORGANIZATION_STATUS_DEFAULT, StringPool.BLANK,
140 site, null);
141 }
142
143
175 @Deprecated
176 @Override
177 public Organization addOrganization(
178 long userId, long parentOrganizationId, String name, String type,
179 boolean recursable, long regionId, long countryId, long statusId,
180 String comments, boolean site, ServiceContext serviceContext)
181 throws PortalException {
182
183 return addOrganization(
184 userId, parentOrganizationId, name, type, regionId, countryId,
185 statusId, comments, site, serviceContext);
186 }
187
188
214 @Override
215 public Organization addOrganization(
216 long userId, long parentOrganizationId, String name, String type,
217 long regionId, long countryId, long statusId, String comments,
218 boolean site, ServiceContext serviceContext)
219 throws PortalException {
220
221
222
223 User user = userPersistence.findByPrimaryKey(userId);
224 parentOrganizationId = getParentOrganizationId(
225 user.getCompanyId(), parentOrganizationId);
226
227 validate(
228 user.getCompanyId(), parentOrganizationId, name, type, countryId,
229 statusId);
230
231 long organizationId = counterLocalService.increment();
232
233 Organization organization = organizationPersistence.create(
234 organizationId);
235
236 if (serviceContext != null) {
237 organization.setUuid(serviceContext.getUuid());
238 }
239
240 organization.setCompanyId(user.getCompanyId());
241 organization.setUserId(user.getUserId());
242 organization.setUserName(user.getFullName());
243 organization.setParentOrganizationId(parentOrganizationId);
244 organization.setTreePath(organization.buildTreePath());
245 organization.setName(name);
246 organization.setType(type);
247 organization.setRecursable(true);
248 organization.setRegionId(regionId);
249 organization.setCountryId(countryId);
250 organization.setStatusId(statusId);
251 organization.setComments(comments);
252 organization.setExpandoBridgeAttributes(serviceContext);
253
254 organizationPersistence.update(organization);
255
256
257
258 long parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
259
260 if (parentOrganizationId !=
261 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
262
263 Organization parentOrganization =
264 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
265
266 if (parentOrganization != null) {
267 Group parentGroup = parentOrganization.getGroup();
268
269 if (site && parentGroup.isSite()) {
270 parentGroupId = parentOrganization.getGroupId();
271 }
272 }
273 }
274
275 Group group = groupLocalService.addGroup(
276 userId, parentGroupId, Organization.class.getName(), organizationId,
277 GroupConstants.DEFAULT_LIVE_GROUP_ID, getLocalizationMap(name),
278 null, GroupConstants.TYPE_SITE_PRIVATE, false,
279 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, null, site, true,
280 null);
281
282
283
284 Role role = roleLocalService.getRole(
285 organization.getCompanyId(), RoleConstants.ORGANIZATION_OWNER);
286
287 userGroupRoleLocalService.addUserGroupRoles(
288 userId, group.getGroupId(), new long[] {role.getRoleId()});
289
290
291
292 addOrganizationResources(userId, organization);
293
294
295
296 if (serviceContext != null) {
297 updateAsset(
298 userId, organization, serviceContext.getAssetCategoryIds(),
299 serviceContext.getAssetTagNames());
300 }
301
302
303
304 if ((serviceContext == null) || serviceContext.isIndexingEnabled()) {
305 Indexer<Organization> indexer =
306 IndexerRegistryUtil.nullSafeGetIndexer(Organization.class);
307
308 indexer.reindex(organization);
309 }
310
311 return organization;
312 }
313
314
321 @Override
322 public void addOrganizationResources(long userId, Organization organization)
323 throws PortalException {
324
325 String name = Organization.class.getName();
326
327 resourceLocalService.addResources(
328 organization.getCompanyId(), 0, userId, name,
329 organization.getOrganizationId(), false, false, false);
330 }
331
332
339 @Override
340 public void addPasswordPolicyOrganizations(
341 long passwordPolicyId, long[] organizationIds) {
342
343 passwordPolicyRelLocalService.addPasswordPolicyRels(
344 passwordPolicyId, Organization.class.getName(), organizationIds);
345 }
346
347
352 @Override
353 public void deleteLogo(long organizationId) throws PortalException {
354 Organization organization = getOrganization(organizationId);
355
356 PortalUtil.updateImageId(organization, false, null, "logoId", 0, 0, 0);
357 }
358
359
366 @Override
367 public Organization deleteOrganization(long organizationId)
368 throws PortalException {
369
370 Organization organization = organizationPersistence.findByPrimaryKey(
371 organizationId);
372
373 return organizationLocalService.deleteOrganization(organization);
374 }
375
376
383 @Override
384 @SystemEvent(type = SystemEventConstants.TYPE_DELETE)
385 public Organization deleteOrganization(Organization organization)
386 throws PortalException {
387
388 if ((userLocalService.getOrganizationUsersCount(
389 organization.getOrganizationId(),
390 WorkflowConstants.STATUS_APPROVED) > 0) ||
391 (organizationPersistence.countByC_P(
392 organization.getCompanyId(),
393 organization.getOrganizationId()) > 0)) {
394
395 throw new RequiredOrganizationException();
396 }
397
398
399
400 assetEntryLocalService.deleteEntry(
401 Organization.class.getName(), organization.getOrganizationId());
402
403
404
405 addressLocalService.deleteAddresses(
406 organization.getCompanyId(), Organization.class.getName(),
407 organization.getOrganizationId());
408
409
410
411 emailAddressLocalService.deleteEmailAddresses(
412 organization.getCompanyId(), Organization.class.getName(),
413 organization.getOrganizationId());
414
415
416
417 expandoRowLocalService.deleteRows(organization.getOrganizationId());
418
419
420
421 passwordPolicyRelLocalService.deletePasswordPolicyRel(
422 Organization.class.getName(), organization.getOrganizationId());
423
424
425
426 phoneLocalService.deletePhones(
427 organization.getCompanyId(), Organization.class.getName(),
428 organization.getOrganizationId());
429
430
431
432 websiteLocalService.deleteWebsites(
433 organization.getCompanyId(), Organization.class.getName(),
434 organization.getOrganizationId());
435
436
437
438 Group group = organization.getGroup();
439
440 if (group.isSite()) {
441 group.setSite(false);
442
443 groupPersistence.update(group);
444 }
445
446 groupLocalService.deleteGroup(group);
447
448
449
450 String name = Organization.class.getName();
451
452 resourceLocalService.deleteResource(
453 organization.getCompanyId(), name,
454 ResourceConstants.SCOPE_INDIVIDUAL,
455 organization.getOrganizationId());
456
457
458
459 organizationPersistence.remove(organization);
460
461
462
463 PermissionCacheUtil.clearCache();
464
465 return organization;
466 }
467
468
476 @Override
477 public Organization fetchOrganization(long companyId, String name) {
478 return organizationPersistence.fetchByC_N(companyId, name);
479 }
480
481 @Override
482 public List<Organization> getGroupUserOrganizations(
483 long groupId, long userId)
484 throws PortalException {
485
486 long[] groupOrganizationIds =
487 groupPersistence.getOrganizationPrimaryKeys(groupId);
488
489 if (groupOrganizationIds.length == 0) {
490 return Collections.emptyList();
491 }
492
493 long[] userOrganizationIds = userPersistence.getOrganizationPrimaryKeys(
494 userId);
495
496 if (userOrganizationIds.length == 0) {
497 return Collections.emptyList();
498 }
499
500 Set<Long> organizationIds = SetUtil.intersect(
501 groupOrganizationIds, userOrganizationIds);
502
503 if (organizationIds.isEmpty()) {
504 return Collections.emptyList();
505 }
506
507 List<Organization> organizations = new ArrayList<>(
508 organizationIds.size());
509
510 for (Long organizationId : organizationIds) {
511 organizations.add(
512 organizationPersistence.findByPrimaryKey(organizationId));
513 }
514
515 return organizations;
516 }
517
518 @Override
519 public List<Organization> getNoAssetOrganizations() {
520 return organizationFinder.findByNoAssets();
521 }
522
523
530 @Override
531 public Organization getOrganization(long companyId, String name)
532 throws PortalException {
533
534 return organizationPersistence.findByC_N(companyId, name);
535 }
536
537
545 @Override
546 public long getOrganizationId(long companyId, String name) {
547 Organization organization = organizationPersistence.fetchByC_N(
548 companyId, name);
549
550 if (organization != null) {
551 return organization.getOrganizationId();
552 }
553 else {
554 return 0;
555 }
556 }
557
558 @Override
559 public List<Organization> getOrganizations(
560 long userId, int start, int end,
561 OrderByComparator<Organization> obc)
562 throws PortalException {
563
564 User user = userPersistence.findByPrimaryKey(userId);
565
566 List<Organization> organizations = ListUtil.copy(
567 userPersistence.getOrganizations(userId));
568
569 Iterator<Organization> iterator = organizations.iterator();
570
571 while (iterator.hasNext()) {
572 Organization organization = iterator.next();
573
574 if (organization.getCompanyId() != user.getCompanyId()) {
575 iterator.remove();
576 }
577 }
578
579 if (organizations.isEmpty()) {
580 return organizations;
581 }
582
583 if (obc == null) {
584 obc = new OrganizationNameComparator(true);
585 }
586
587 Collections.sort(organizations, obc);
588
589 return ListUtil.subList(organizations, start, end);
590 }
591
592
600 @Override
601 public List<Organization> getOrganizations(
602 long companyId, long parentOrganizationId) {
603
604 return getOrganizations(
605 companyId, parentOrganizationId, QueryUtil.ALL_POS,
606 QueryUtil.ALL_POS);
607 }
608
609
632 @Override
633 public List<Organization> getOrganizations(
634 long companyId, long parentOrganizationId, int start, int end) {
635
636 if (parentOrganizationId ==
637 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
638
639 return organizationPersistence.findByCompanyId(
640 companyId, start, end);
641 }
642 else {
643 return organizationPersistence.findByC_P(
644 companyId, parentOrganizationId, start, end);
645 }
646 }
647
648
654 @Override
655 public List<Organization> getOrganizations(long[] organizationIds)
656 throws PortalException {
657
658 List<Organization> organizations = new ArrayList<>(
659 organizationIds.length);
660
661 for (long organizationId : organizationIds) {
662 Organization organization = getOrganization(organizationId);
663
664 organizations.add(organization);
665 }
666
667 return organizations;
668 }
669
670
678 @Override
679 public int getOrganizationsCount(
680 long companyId, long parentOrganizationId) {
681
682 if (parentOrganizationId ==
683 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
684
685 return organizationPersistence.countByCompanyId(companyId);
686 }
687 else {
688 return organizationPersistence.countByC_P(
689 companyId, parentOrganizationId);
690 }
691 }
692
693
700 @Override
701 public List<Organization> getParentOrganizations(long organizationId)
702 throws PortalException {
703
704 if (organizationId ==
705 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
706
707 return new ArrayList<>();
708 }
709
710 Organization organization = organizationPersistence.findByPrimaryKey(
711 organizationId);
712
713 return organization.getAncestors();
714 }
715
716
723 @Override
724 public List<Organization> getSuborganizations(
725 List<Organization> organizations) {
726
727 List<Organization> allSuborganizations = new ArrayList<>();
728
729 for (int i = 0; i < organizations.size(); i++) {
730 Organization organization = organizations.get(i);
731
732 List<Organization> suborganizations =
733 organizationPersistence.findByC_P(
734 organization.getCompanyId(),
735 organization.getOrganizationId());
736
737 addSuborganizations(allSuborganizations, suborganizations);
738 }
739
740 return allSuborganizations;
741 }
742
743
750 @Override
751 public List<Organization> getSuborganizations(
752 long companyId, long organizationId) {
753
754 return organizationPersistence.findByC_P(companyId, organizationId);
755 }
756
757
764 @Override
765 public int getSuborganizationsCount(long companyId, long organizationId) {
766 return organizationPersistence.countByC_P(companyId, organizationId);
767 }
768
769
778 @Override
779 public List<Organization> getSubsetOrganizations(
780 List<Organization> allOrganizations,
781 List<Organization> availableOrganizations) {
782
783 List<Organization> subsetOrganizations = new ArrayList<>();
784
785 for (Organization organization : allOrganizations) {
786 if (availableOrganizations.contains(organization)) {
787 subsetOrganizations.add(organization);
788 }
789 }
790
791 return subsetOrganizations;
792 }
793
794
813 @Override
814 public long[] getUserOrganizationIds(
815 long userId, boolean includeAdministrative)
816 throws PortalException {
817
818 if (!includeAdministrative) {
819 return userPersistence.getOrganizationPrimaryKeys(userId);
820 }
821
822 Set<Long> organizationIds = SetUtil.fromArray(
823 userPersistence.getOrganizationPrimaryKeys(userId));
824
825 List<UserGroupRole> userGroupRoles =
826 userGroupRoleLocalService.getUserGroupRoles(userId);
827
828 for (UserGroupRole userGroupRole : userGroupRoles) {
829 Role role = userGroupRole.getRole();
830
831 String roleName = role.getName();
832
833 if (roleName.equals(RoleConstants.ORGANIZATION_ADMINISTRATOR) ||
834 roleName.equals(RoleConstants.ORGANIZATION_OWNER)) {
835
836 Group group = userGroupRole.getGroup();
837
838 organizationIds.add(group.getOrganizationId());
839 }
840 }
841
842 return ArrayUtil.toLongArray(organizationIds);
843 }
844
845
864 @Override
865 public List<Organization> getUserOrganizations(
866 long userId, boolean includeAdministrative)
867 throws PortalException {
868
869 if (!includeAdministrative) {
870 return getUserOrganizations(userId);
871 }
872
873 Set<Organization> organizations = new HashSet<>(
874 getUserOrganizations(userId));
875
876 List<UserGroupRole> userGroupRoles =
877 userGroupRoleLocalService.getUserGroupRoles(userId);
878
879 for (UserGroupRole userGroupRole : userGroupRoles) {
880 Role role = userGroupRole.getRole();
881
882 String roleName = role.getName();
883
884 if (roleName.equals(RoleConstants.ORGANIZATION_ADMINISTRATOR) ||
885 roleName.equals(RoleConstants.ORGANIZATION_OWNER)) {
886
887 Group group = userGroupRole.getGroup();
888
889 Organization organization =
890 organizationPersistence.findByPrimaryKey(
891 group.getOrganizationId());
892
893 organizations.add(organization);
894 }
895 }
896
897 return new ArrayList<>(organizations);
898 }
899
900
909 @Override
910 public boolean hasPasswordPolicyOrganization(
911 long passwordPolicyId, long organizationId) {
912
913 return passwordPolicyRelLocalService.hasPasswordPolicyRel(
914 passwordPolicyId, Organization.class.getName(), organizationId);
915 }
916
917
963 @Override
964 public boolean hasUserOrganization(
965 long userId, long organizationId, boolean inheritSuborganizations,
966 boolean includeSpecifiedOrganization)
967 throws PortalException {
968
969 if (!inheritSuborganizations) {
970 return userPersistence.containsOrganization(userId, organizationId);
971 }
972
973 LinkedHashMap<String, Object> params = new LinkedHashMap<>();
974
975 List<Organization> organizationsTree = new ArrayList<>();
976
977 Organization organization = organizationPersistence.findByPrimaryKey(
978 organizationId);
979
980 if (!includeSpecifiedOrganization) {
981 organizationsTree.add(organization);
982 }
983 else {
984 organizationsTree.add(organization.getParentOrganization());
985 }
986
987 params.put("usersOrgsTree", organizationsTree);
988
989 if (userFinder.countByUser(userId, params) > 0) {
990 return true;
991 }
992
993 return false;
994 }
995
996
1007 @Override
1008 public void rebuildTree(long companyId) throws PortalException {
1009 TreePathUtil.rebuildTree(
1010 companyId, OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID,
1011 StringPool.SLASH,
1012 new TreeModelTasksAdapter<Organization>() {
1013
1014 @Override
1015 public List<Organization> findTreeModels(
1016 long previousId, long companyId, long parentPrimaryKey,
1017 int size) {
1018
1019 return organizationPersistence.findByO_C_P(
1020 previousId, companyId, parentPrimaryKey,
1021 QueryUtil.ALL_POS, size,
1022 new OrganizationIdComparator(true));
1023 }
1024
1025 }
1026 );
1027 }
1028
1029
1060 @Override
1061 public Hits search(
1062 long companyId, long parentOrganizationId, String keywords,
1063 LinkedHashMap<String, Object> params, int start, int end, Sort sort) {
1064
1065 String name = null;
1066 String type = null;
1067 String street = null;
1068 String city = null;
1069 String zip = null;
1070 String region = null;
1071 String country = null;
1072 boolean andOperator = false;
1073
1074 if (Validator.isNotNull(keywords)) {
1075 name = keywords;
1076 type = keywords;
1077 street = keywords;
1078 city = keywords;
1079 zip = keywords;
1080 region = keywords;
1081 country = keywords;
1082 }
1083 else {
1084 andOperator = true;
1085 }
1086
1087 if (params != null) {
1088 params.put("keywords", keywords);
1089 }
1090
1091 return search(
1092 companyId, parentOrganizationId, name, type, street, city, zip,
1093 region, country, params, andOperator, start, end, sort);
1094 }
1095
1096
1131 @Override
1132 public List<Organization> search(
1133 long companyId, long parentOrganizationId, String keywords, String type,
1134 Long regionId, Long countryId, LinkedHashMap<String, Object> params,
1135 int start, int end) {
1136
1137 return search(
1138 companyId, parentOrganizationId, keywords, type, regionId,
1139 countryId, params, start, end,
1140 new OrganizationNameComparator(true));
1141 }
1142
1143
1181 @Override
1182 public List<Organization> search(
1183 long companyId, long parentOrganizationId, String keywords, String type,
1184 Long regionId, Long countryId, LinkedHashMap<String, Object> params,
1185 int start, int end, OrderByComparator<Organization> obc) {
1186
1187 String parentOrganizationIdComparator = StringPool.EQUAL;
1188
1189 if (parentOrganizationId ==
1190 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1191
1192 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1193 }
1194
1195 return organizationFinder.findByKeywords(
1196 companyId, parentOrganizationId, parentOrganizationIdComparator,
1197 keywords, type, regionId, countryId, params, start, end, obc);
1198 }
1199
1200
1242 @Override
1243 public List<Organization> search(
1244 long companyId, long parentOrganizationId, String name, String type,
1245 String street, String city, String zip, Long regionId, Long countryId,
1246 LinkedHashMap<String, Object> params, boolean andOperator, int start,
1247 int end) {
1248
1249 return search(
1250 companyId, parentOrganizationId, name, type, street, city, zip,
1251 regionId, countryId, params, andOperator, start, end,
1252 new OrganizationNameComparator(true));
1253 }
1254
1255
1300 @Override
1301 public List<Organization> search(
1302 long companyId, long parentOrganizationId, String name, String type,
1303 String street, String city, String zip, Long regionId, Long countryId,
1304 LinkedHashMap<String, Object> params, boolean andOperator, int start,
1305 int end, OrderByComparator<Organization> obc) {
1306
1307 String parentOrganizationIdComparator = StringPool.EQUAL;
1308
1309 if (parentOrganizationId ==
1310 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1311
1312 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1313 }
1314
1315 return organizationFinder.findByC_PO_N_T_S_C_Z_R_C(
1316 companyId, parentOrganizationId, parentOrganizationIdComparator,
1317 name, type, street, city, zip, regionId, countryId, params,
1318 andOperator, start, end, obc);
1319 }
1320
1321
1360 @Override
1361 public Hits search(
1362 long companyId, long parentOrganizationId, String name, String type,
1363 String street, String city, String zip, String region, String country,
1364 LinkedHashMap<String, Object> params, boolean andSearch, int start,
1365 int end, Sort sort) {
1366
1367 try {
1368 Indexer<Organization> indexer =
1369 IndexerRegistryUtil.nullSafeGetIndexer(Organization.class);
1370
1371 SearchContext searchContext = buildSearchContext(
1372 companyId, parentOrganizationId, name, type, street, city, zip,
1373 region, country, params, andSearch, start, end, sort);
1374
1375 return indexer.search(searchContext);
1376 }
1377 catch (Exception e) {
1378 throw new SystemException(e);
1379 }
1380 }
1381
1382
1403 @Override
1404 public int searchCount(
1405 long companyId, long parentOrganizationId, String keywords, String type,
1406 Long regionId, Long countryId, LinkedHashMap<String, Object> params) {
1407
1408 Indexer<?> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1409 Organization.class);
1410
1411 if (!indexer.isIndexerEnabled() ||
1412 !PropsValues.ORGANIZATIONS_SEARCH_WITH_INDEX ||
1413 isUseCustomSQL(params)) {
1414
1415 String parentOrganizationIdComparator = StringPool.EQUAL;
1416
1417 if (parentOrganizationId ==
1418 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1419
1420 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1421 }
1422
1423 return organizationFinder.countByKeywords(
1424 companyId, parentOrganizationId, parentOrganizationIdComparator,
1425 keywords, type, regionId, countryId, params);
1426 }
1427
1428 try {
1429 String name = null;
1430 String street = null;
1431 String city = null;
1432 String zip = null;
1433 boolean andOperator = false;
1434
1435 if (Validator.isNotNull(keywords)) {
1436 name = keywords;
1437 street = keywords;
1438 city = keywords;
1439 zip = keywords;
1440 }
1441 else {
1442 andOperator = true;
1443 }
1444
1445 if (params != null) {
1446 params.put("keywords", keywords);
1447 }
1448
1449 SearchContext searchContext = buildSearchContext(
1450 companyId, parentOrganizationId, name, type, street, city, zip,
1451 regionId, countryId, params, andOperator, QueryUtil.ALL_POS,
1452 QueryUtil.ALL_POS, null);
1453
1454 return (int)indexer.searchCount(searchContext);
1455 }
1456 catch (Exception e) {
1457 throw new SystemException(e);
1458 }
1459 }
1460
1461
1489 @Override
1490 public int searchCount(
1491 long companyId, long parentOrganizationId, String name, String type,
1492 String street, String city, String zip, Long regionId, Long countryId,
1493 LinkedHashMap<String, Object> params, boolean andOperator) {
1494
1495 Indexer<?> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1496 Organization.class);
1497
1498 if (!indexer.isIndexerEnabled() ||
1499 !PropsValues.ORGANIZATIONS_SEARCH_WITH_INDEX ||
1500 isUseCustomSQL(params)) {
1501
1502 String parentOrganizationIdComparator = StringPool.EQUAL;
1503
1504 if (parentOrganizationId ==
1505 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1506
1507 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1508 }
1509
1510 return organizationFinder.countByC_PO_N_T_S_C_Z_R_C(
1511 companyId, parentOrganizationId, parentOrganizationIdComparator,
1512 name, type, street, city, zip, regionId, countryId, params,
1513 andOperator);
1514 }
1515
1516 try {
1517 SearchContext searchContext = buildSearchContext(
1518 companyId, parentOrganizationId, name, type, street, city, zip,
1519 regionId, countryId, params, andOperator, QueryUtil.ALL_POS,
1520 QueryUtil.ALL_POS, null);
1521
1522 return (int)indexer.searchCount(searchContext);
1523 }
1524 catch (Exception e) {
1525 throw new SystemException(e);
1526 }
1527 }
1528
1529 @Override
1530 public BaseModelSearchResult<Organization> searchOrganizations(
1531 long companyId, long parentOrganizationId, String keywords,
1532 LinkedHashMap<String, Object> params, int start, int end, Sort sort)
1533 throws PortalException {
1534
1535 String name = null;
1536 String type = null;
1537 String street = null;
1538 String city = null;
1539 String zip = null;
1540 String region = null;
1541 String country = null;
1542 boolean andOperator = false;
1543
1544 if (Validator.isNotNull(keywords)) {
1545 name = keywords;
1546 type = keywords;
1547 street = keywords;
1548 city = keywords;
1549 zip = keywords;
1550 region = keywords;
1551 country = keywords;
1552 }
1553 else {
1554 andOperator = true;
1555 }
1556
1557 if (params != null) {
1558 params.put("keywords", keywords);
1559 }
1560
1561 return searchOrganizations(
1562 companyId, parentOrganizationId, name, type, street, city, zip,
1563 region, country, params, andOperator, start, end, sort);
1564 }
1565
1566 @Override
1567 public BaseModelSearchResult<Organization> searchOrganizations(
1568 long companyId, long parentOrganizationId, String name, String type,
1569 String street, String city, String zip, String region,
1570 String country, LinkedHashMap<String, Object> params,
1571 boolean andSearch, int start, int end, Sort sort)
1572 throws PortalException {
1573
1574 Indexer<Organization> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1575 Organization.class);
1576
1577 SearchContext searchContext = buildSearchContext(
1578 companyId, parentOrganizationId, name, type, street, city, zip,
1579 region, country, params, andSearch, start, end, sort);
1580
1581 for (int i = 0; i < 10; i++) {
1582 Hits hits = indexer.search(searchContext);
1583
1584 List<Organization> organizations = UsersAdminUtil.getOrganizations(
1585 hits);
1586
1587 if (organizations != null) {
1588 return new BaseModelSearchResult<>(
1589 organizations, hits.getLength());
1590 }
1591 }
1592
1593 throw new SearchException(
1594 "Unable to fix the search index after 10 attempts");
1595 }
1596
1597
1604 @Override
1605 public void setGroupOrganizations(long groupId, long[] organizationIds) {
1606 groupPersistence.setOrganizations(groupId, organizationIds);
1607
1608 PermissionCacheUtil.clearCache();
1609 }
1610
1611
1617 @Override
1618 public void unsetGroupOrganizations(long groupId, long[] organizationIds) {
1619 groupPersistence.removeOrganizations(groupId, organizationIds);
1620
1621 PermissionCacheUtil.clearCache();
1622 }
1623
1624
1630 @Override
1631 public void unsetPasswordPolicyOrganizations(
1632 long passwordPolicyId, long[] organizationIds) {
1633
1634 passwordPolicyRelLocalService.deletePasswordPolicyRels(
1635 passwordPolicyId, Organization.class.getName(), organizationIds);
1636 }
1637
1638
1647 @Override
1648 public void updateAsset(
1649 long userId, Organization organization, long[] assetCategoryIds,
1650 String[] assetTagNames)
1651 throws PortalException {
1652
1653 User user = userPersistence.findByPrimaryKey(userId);
1654
1655 Company company = companyPersistence.findByPrimaryKey(
1656 user.getCompanyId());
1657
1658 Group companyGroup = company.getGroup();
1659
1660 assetEntryLocalService.updateEntry(
1661 userId, companyGroup.getGroupId(), null, null,
1662 Organization.class.getName(), organization.getOrganizationId(),
1663 organization.getUuid(), 0, assetCategoryIds, assetTagNames, false,
1664 null, null, null, null, organization.getName(), StringPool.BLANK,
1665 null, null, null, 0, 0, null);
1666 }
1667
1668
1694 @Deprecated
1695 @Override
1696 public Organization updateOrganization(
1697 long companyId, long organizationId, long parentOrganizationId,
1698 String name, String type, boolean recursable, long regionId,
1699 long countryId, long statusId, String comments, boolean site,
1700 ServiceContext serviceContext)
1701 throws PortalException {
1702
1703 return updateOrganization(
1704 companyId, organizationId, parentOrganizationId, name, type,
1705 regionId, countryId, statusId, comments, true, null, site,
1706 serviceContext);
1707 }
1708
1709
1732 @Override
1733 public Organization updateOrganization(
1734 long companyId, long organizationId, long parentOrganizationId,
1735 String name, String type, long regionId, long countryId,
1736 long statusId, String comments, boolean logo, byte[] logoBytes,
1737 boolean site, ServiceContext serviceContext)
1738 throws PortalException {
1739
1740
1741
1742 parentOrganizationId = getParentOrganizationId(
1743 companyId, parentOrganizationId);
1744
1745 validate(
1746 companyId, organizationId, parentOrganizationId, name, type,
1747 countryId, statusId);
1748
1749 Organization organization = organizationPersistence.findByPrimaryKey(
1750 organizationId);
1751
1752 long oldParentOrganizationId = organization.getParentOrganizationId();
1753 String oldName = organization.getName();
1754
1755 organization.setParentOrganizationId(parentOrganizationId);
1756 organization.setTreePath(organization.buildTreePath());
1757 organization.setName(name);
1758 organization.setType(type);
1759 organization.setRecursable(true);
1760 organization.setRegionId(regionId);
1761 organization.setCountryId(countryId);
1762 organization.setStatusId(statusId);
1763 organization.setComments(comments);
1764
1765 PortalUtil.updateImageId(
1766 organization, logo, logoBytes, "logoId",
1767 PrefsPropsUtil.getLong(PropsKeys.USERS_IMAGE_MAX_SIZE),
1768 PropsValues.USERS_IMAGE_MAX_HEIGHT,
1769 PropsValues.USERS_IMAGE_MAX_WIDTH);
1770
1771 organization.setExpandoBridgeAttributes(serviceContext);
1772
1773 organizationPersistence.update(organization);
1774
1775
1776
1777 Group group = organization.getGroup();
1778
1779 long parentGroupId = group.getParentGroupId();
1780
1781 boolean createSite = false;
1782
1783 if (!group.isSite() && site) {
1784 createSite = true;
1785 }
1786
1787 boolean organizationGroup = isOrganizationGroup(
1788 oldParentOrganizationId, group.getParentGroupId());
1789
1790 if (createSite || organizationGroup) {
1791 if (parentOrganizationId !=
1792 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1793
1794 Organization parentOrganization =
1795 organizationPersistence.fetchByPrimaryKey(
1796 parentOrganizationId);
1797
1798 Group parentGroup = parentOrganization.getGroup();
1799
1800 if (site && parentGroup.isSite()) {
1801 parentGroupId = parentOrganization.getGroupId();
1802 }
1803 else {
1804 parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
1805 }
1806 }
1807 else {
1808 parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
1809 }
1810 }
1811
1812 if (createSite || !oldName.equals(name) || organizationGroup) {
1813 groupLocalService.updateGroup(
1814 group.getGroupId(), parentGroupId, getLocalizationMap(name),
1815 group.getDescriptionMap(), group.getType(),
1816 group.isManualMembership(), group.getMembershipRestriction(),
1817 group.getFriendlyURL(), group.isInheritContent(),
1818 group.isActive(), null);
1819 }
1820
1821 if (group.isSite() != site) {
1822 groupLocalService.updateSite(group.getGroupId(), site);
1823 }
1824
1825
1826
1827 if (createSite) {
1828 List<Organization> childOrganizations =
1829 organizationLocalService.getOrganizations(
1830 companyId, organizationId);
1831
1832 for (Organization childOrganization : childOrganizations) {
1833 Group childGroup = childOrganization.getGroup();
1834
1835 if (childGroup.isSite() &&
1836 (childGroup.getParentGroupId() ==
1837 GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
1838
1839 childGroup.setParentGroupId(group.getGroupId());
1840
1841 groupLocalService.updateGroup(childGroup);
1842 }
1843 }
1844 }
1845
1846
1847
1848 if (serviceContext != null) {
1849 updateAsset(
1850 serviceContext.getUserId(), organization,
1851 serviceContext.getAssetCategoryIds(),
1852 serviceContext.getAssetTagNames());
1853 }
1854
1855
1856
1857 Indexer<Organization> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1858 Organization.class);
1859
1860 if (oldParentOrganizationId != parentOrganizationId) {
1861 long[] reindexOrganizationIds = getReindexOrganizationIds(
1862 organization);
1863
1864 List<Organization> reindexOrganizations = new ArrayList<>(
1865 reindexOrganizationIds.length);
1866
1867 for (long reindexOrganizationId : reindexOrganizationIds) {
1868 Organization reindexOrganization = fetchOrganization(
1869 reindexOrganizationId);
1870
1871 reindexOrganizations.add(reindexOrganization);
1872 }
1873
1874 indexer.reindex(reindexOrganizations);
1875 }
1876 else {
1877 indexer.reindex(organization);
1878 }
1879
1880 return organization;
1881 }
1882
1883
1907 @Deprecated
1908 @Override
1909 public Organization updateOrganization(
1910 long companyId, long organizationId, long parentOrganizationId,
1911 String name, String type, long regionId, long countryId,
1912 long statusId, String comments, boolean site,
1913 ServiceContext serviceContext)
1914 throws PortalException {
1915
1916 return updateOrganization(
1917 companyId, organizationId, parentOrganizationId, name, type,
1918 regionId, countryId, statusId, comments, site, serviceContext);
1919 }
1920
1921 protected void addSuborganizations(
1922 List<Organization> allSuborganizations,
1923 List<Organization> organizations) {
1924
1925 for (Organization organization : organizations) {
1926 if (!allSuborganizations.contains(organization)) {
1927 allSuborganizations.add(organization);
1928
1929 List<Organization> suborganizations =
1930 organizationPersistence.findByC_P(
1931 organization.getCompanyId(),
1932 organization.getOrganizationId());
1933
1934 addSuborganizations(allSuborganizations, suborganizations);
1935 }
1936 }
1937 }
1938
1939 protected SearchContext buildSearchContext(
1940 long companyId, long parentOrganizationId, String name, String type,
1941 String street, String city, String zip, Long regionId, Long countryId,
1942 LinkedHashMap<String, Object> params, boolean andSearch, int start,
1943 int end, Sort sort) {
1944
1945 String regionCode = null;
1946
1947 if (regionId != null) {
1948 Region region = regionPersistence.fetchByPrimaryKey(regionId);
1949
1950 regionCode = region.getRegionCode();
1951 }
1952
1953 String countryName = null;
1954
1955 if (countryId != null) {
1956 Country country = countryPersistence.fetchByPrimaryKey(countryId);
1957
1958 countryName = country.getName();
1959 }
1960
1961 return buildSearchContext(
1962 companyId, parentOrganizationId, name, type, street, city, zip,
1963 regionCode, countryName, params, andSearch, start, end, sort);
1964 }
1965
1966 protected SearchContext buildSearchContext(
1967 long companyId, long parentOrganizationId, String name, String type,
1968 String street, String city, String zip, String region, String country,
1969 LinkedHashMap<String, Object> params, boolean andSearch, int start,
1970 int end, Sort sort) {
1971
1972 SearchContext searchContext = new SearchContext();
1973
1974 searchContext.setAndSearch(andSearch);
1975
1976 Map<String, Serializable> attributes = new HashMap<>();
1977
1978 attributes.put("city", city);
1979 attributes.put("country", country);
1980 attributes.put("name", name);
1981 attributes.put("params", params);
1982 attributes.put(
1983 "parentOrganizationId", String.valueOf(parentOrganizationId));
1984 attributes.put("region", region);
1985 attributes.put("street", street);
1986 attributes.put("type", type);
1987 attributes.put("zip", zip);
1988
1989 searchContext.setAttributes(attributes);
1990
1991 searchContext.setCompanyId(companyId);
1992 searchContext.setEnd(end);
1993
1994 if (params != null) {
1995 String keywords = (String)params.remove("keywords");
1996
1997 if (Validator.isNotNull(keywords)) {
1998 searchContext.setKeywords(keywords);
1999 }
2000 }
2001
2002 if (sort != null) {
2003 searchContext.setSorts(sort);
2004 }
2005
2006 searchContext.setStart(start);
2007
2008 QueryConfig queryConfig = searchContext.getQueryConfig();
2009
2010 queryConfig.setHighlightEnabled(false);
2011 queryConfig.setScoreEnabled(false);
2012
2013 return searchContext;
2014 }
2015
2016 protected long getParentOrganizationId(
2017 long companyId, long parentOrganizationId) {
2018
2019 if (parentOrganizationId !=
2020 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
2021
2022
2023
2024
2025 Organization parentOrganization =
2026 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
2027
2028 if ((parentOrganization == null) ||
2029 (companyId != parentOrganization.getCompanyId())) {
2030
2031 parentOrganizationId =
2032 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID;
2033 }
2034 }
2035
2036 return parentOrganizationId;
2037 }
2038
2039 protected long[] getReindexOrganizationIds(Organization organization)
2040 throws PortalException {
2041
2042 List<Organization> organizations = organizationPersistence.findByC_T(
2043 organization.getCompanyId(),
2044 CustomSQLUtil.keywords(organization.getTreePath())[0],
2045 QueryUtil.ALL_POS, QueryUtil.ALL_POS,
2046 new OrganizationNameComparator(true));
2047
2048 long[] organizationIds = new long[organizations.size()];
2049
2050 for (int i = 0; i < organizations.size(); i++) {
2051 Organization curOrganization = organizations.get(i);
2052
2053 curOrganization.setTreePath(curOrganization.buildTreePath());
2054
2055 organizationPersistence.update(curOrganization);
2056
2057 organizationIds[i] = curOrganization.getOrganizationId();
2058 }
2059
2060 if (!ArrayUtil.contains(
2061 organizationIds, organization.getOrganizationId())) {
2062
2063 organizationIds = ArrayUtil.append(
2064 organizationIds, organization.getOrganizationId());
2065 }
2066
2067 return organizationIds;
2068 }
2069
2070 protected boolean isOrganizationGroup(long organizationId, long groupId) {
2071 if ((organizationId ==
2072 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) &&
2073 (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
2074
2075 return true;
2076 }
2077
2078 if (organizationId !=
2079 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
2080
2081 Organization organization =
2082 organizationPersistence.fetchByPrimaryKey(organizationId);
2083
2084 if (organization.getGroupId() == groupId) {
2085 return true;
2086 }
2087 }
2088
2089 return false;
2090 }
2091
2092 protected boolean isParentOrganization(
2093 long parentOrganizationId, long organizationId)
2094 throws PortalException {
2095
2096
2097
2098
2099 if (organizationId ==
2100 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
2101
2102 return false;
2103 }
2104
2105 Organization organization = organizationPersistence.findByPrimaryKey(
2106 organizationId);
2107
2108 String treePath = organization.getTreePath();
2109
2110 if (treePath.contains(
2111 StringPool.SLASH + parentOrganizationId + StringPool.SLASH)) {
2112
2113 return true;
2114 }
2115 else {
2116 return false;
2117 }
2118 }
2119
2120 protected boolean isUseCustomSQL(LinkedHashMap<String, Object> params) {
2121 if (MapUtil.isEmpty(params)) {
2122 return false;
2123 }
2124
2125 return true;
2126 }
2127
2128 protected void validate(
2129 long companyId, long organizationId, long parentOrganizationId,
2130 String name, String type, long countryId, long statusId)
2131 throws PortalException {
2132
2133 if (!ArrayUtil.contains(PropsValues.ORGANIZATIONS_TYPES, type)) {
2134 throw new OrganizationTypeException(
2135 "Invalid organization type " + type);
2136 }
2137
2138 if (parentOrganizationId ==
2139 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
2140
2141 if (!OrganizationImpl.isRootable(type)) {
2142 throw new OrganizationParentException(
2143 "Organization of type " + type + " cannot be a root");
2144 }
2145 }
2146 else {
2147 Organization parentOrganization =
2148 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
2149
2150 if (parentOrganization == null) {
2151 throw new OrganizationParentException(
2152 "Organization " + parentOrganizationId + " doesn't exist");
2153 }
2154
2155 String[] childrenTypes = OrganizationImpl.getChildrenTypes(
2156 parentOrganization.getType());
2157
2158 if (childrenTypes.length == 0) {
2159 throw new OrganizationParentException(
2160 "Organization of type " + type + " cannot have children");
2161 }
2162
2163 if ((companyId != parentOrganization.getCompanyId()) ||
2164 (parentOrganizationId == organizationId)) {
2165
2166 throw new OrganizationParentException();
2167 }
2168
2169 if (!ArrayUtil.contains(childrenTypes, type)) {
2170 throw new OrganizationParentException(
2171 "Type " + type + " not allowed as child of " +
2172 parentOrganization.getType());
2173 }
2174 }
2175
2176 if ((organizationId > 0) &&
2177 (parentOrganizationId !=
2178 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID)) {
2179
2180
2181
2182 if (isParentOrganization(organizationId, parentOrganizationId)) {
2183 throw new OrganizationParentException();
2184 }
2185 }
2186
2187 if (Validator.isNull(name)) {
2188 throw new OrganizationNameException();
2189 }
2190 else {
2191 Organization organization = organizationPersistence.fetchByC_N(
2192 companyId, name);
2193
2194 if ((organization != null) &&
2195 StringUtil.equalsIgnoreCase(organization.getName(), name)) {
2196
2197 if ((organizationId <= 0) ||
2198 (organization.getOrganizationId() != organizationId)) {
2199
2200 throw new DuplicateOrganizationException(
2201 "There is another organization named " + name);
2202 }
2203 }
2204 }
2205
2206 boolean countryRequired = GetterUtil.getBoolean(
2207 PropsUtil.get(
2208 PropsKeys.ORGANIZATIONS_COUNTRY_REQUIRED, new Filter(type)));
2209
2210 if (countryRequired || (countryId > 0)) {
2211 countryPersistence.findByPrimaryKey(countryId);
2212 }
2213
2214 listTypeLocalService.validate(
2215 statusId, ListTypeConstants.ORGANIZATION_STATUS);
2216 }
2217
2218 protected void validate(
2219 long companyId, long parentOrganizationId, String name, String type,
2220 long countryId, long statusId)
2221 throws PortalException {
2222
2223 validate(
2224 companyId, 0, parentOrganizationId, name, type, countryId,
2225 statusId);
2226 }
2227
2228 }