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.Hits;
027 import com.liferay.portal.kernel.search.Indexer;
028 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
029 import com.liferay.portal.kernel.search.QueryConfig;
030 import com.liferay.portal.kernel.search.SearchContext;
031 import com.liferay.portal.kernel.search.Sort;
032 import com.liferay.portal.kernel.util.ArrayUtil;
033 import com.liferay.portal.kernel.util.GetterUtil;
034 import com.liferay.portal.kernel.util.ListUtil;
035 import com.liferay.portal.kernel.util.OrderByComparator;
036 import com.liferay.portal.kernel.util.PropsKeys;
037 import com.liferay.portal.kernel.util.StringPool;
038 import com.liferay.portal.kernel.util.StringUtil;
039 import com.liferay.portal.kernel.util.TreeModelFinder;
040 import com.liferay.portal.kernel.util.TreePathUtil;
041 import com.liferay.portal.kernel.util.Validator;
042 import com.liferay.portal.kernel.workflow.WorkflowConstants;
043 import com.liferay.portal.model.Company;
044 import com.liferay.portal.model.Group;
045 import com.liferay.portal.model.GroupConstants;
046 import com.liferay.portal.model.LayoutSet;
047 import com.liferay.portal.model.ListTypeConstants;
048 import com.liferay.portal.model.Organization;
049 import com.liferay.portal.model.OrganizationConstants;
050 import com.liferay.portal.model.ResourceConstants;
051 import com.liferay.portal.model.Role;
052 import com.liferay.portal.model.RoleConstants;
053 import com.liferay.portal.model.User;
054 import com.liferay.portal.model.UserGroupRole;
055 import com.liferay.portal.model.impl.OrganizationImpl;
056 import com.liferay.portal.security.permission.PermissionCacheUtil;
057 import com.liferay.portal.service.ServiceContext;
058 import com.liferay.portal.service.base.OrganizationLocalServiceBaseImpl;
059 import com.liferay.portal.util.PropsUtil;
060 import com.liferay.portal.util.PropsValues;
061 import com.liferay.portal.util.comparator.OrganizationIdComparator;
062 import com.liferay.portal.util.comparator.OrganizationNameComparator;
063 import com.liferay.util.dao.orm.CustomSQLUtil;
064
065 import java.io.Serializable;
066
067 import java.util.ArrayList;
068 import java.util.Collections;
069 import java.util.Date;
070 import java.util.HashMap;
071 import java.util.HashSet;
072 import java.util.Iterator;
073 import java.util.LinkedHashMap;
074 import java.util.List;
075 import java.util.Map;
076 import java.util.Set;
077
078
088 public class OrganizationLocalServiceImpl
089 extends OrganizationLocalServiceBaseImpl {
090
091
100 @Override
101 public void addGroupOrganizations(long groupId, long[] organizationIds)
102 throws PortalException, SystemException {
103
104 groupPersistence.addOrganizations(groupId, organizationIds);
105
106 PermissionCacheUtil.clearCache();
107 }
108
109
131 @Override
132 public Organization addOrganization(
133 long userId, long parentOrganizationId, String name, boolean site)
134 throws PortalException, SystemException {
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
179 @Override
180 public Organization addOrganization(
181 long userId, long parentOrganizationId, String name, String type,
182 boolean recursable, long regionId, long countryId, int statusId,
183 String comments, boolean site, ServiceContext serviceContext)
184 throws PortalException, SystemException {
185
186 return addOrganization(
187 userId, parentOrganizationId, name, type, regionId, countryId,
188 statusId, comments, site, serviceContext);
189 }
190
191
221 @Override
222 public Organization addOrganization(
223 long userId, long parentOrganizationId, String name, String type,
224 long regionId, long countryId, int statusId, String comments,
225 boolean site, ServiceContext serviceContext)
226 throws PortalException, SystemException {
227
228
229
230 User user = userPersistence.findByPrimaryKey(userId);
231 parentOrganizationId = getParentOrganizationId(
232 user.getCompanyId(), parentOrganizationId);
233 Date now = new Date();
234
235 validate(
236 user.getCompanyId(), parentOrganizationId, name, type, countryId,
237 statusId);
238
239 long organizationId = counterLocalService.increment();
240
241 Organization organization = organizationPersistence.create(
242 organizationId);
243
244 if (serviceContext != null) {
245 organization.setUuid(serviceContext.getUuid());
246 }
247
248 organization.setCompanyId(user.getCompanyId());
249 organization.setUserId(user.getUserId());
250 organization.setUserName(user.getFullName());
251
252 if (serviceContext != null) {
253 organization.setCreateDate(serviceContext.getCreateDate(now));
254 organization.setModifiedDate(serviceContext.getModifiedDate(now));
255 }
256 else {
257 organization.setCreateDate(now);
258 organization.setModifiedDate(now);
259 }
260
261 organization.setParentOrganizationId(parentOrganizationId);
262 organization.setTreePath(organization.buildTreePath());
263 organization.setName(name);
264 organization.setType(type);
265 organization.setRecursable(true);
266 organization.setRegionId(regionId);
267 organization.setCountryId(countryId);
268 organization.setStatusId(statusId);
269 organization.setComments(comments);
270 organization.setExpandoBridgeAttributes(serviceContext);
271
272 organizationPersistence.update(organization);
273
274
275
276 long parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
277
278 if (parentOrganizationId !=
279 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
280
281 Organization parentOrganization =
282 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
283
284 if (parentOrganization != null) {
285 Group parentGroup = parentOrganization.getGroup();
286
287 if (site && parentGroup.isSite()) {
288 parentGroupId = parentOrganization.getGroupId();
289 }
290 }
291 }
292
293 Group group = groupLocalService.addGroup(
294 userId, parentGroupId, Organization.class.getName(), organizationId,
295 GroupConstants.DEFAULT_LIVE_GROUP_ID, name, null,
296 GroupConstants.TYPE_SITE_PRIVATE, false,
297 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, null, site, true,
298 null);
299
300
301
302 Role role = roleLocalService.getRole(
303 organization.getCompanyId(), RoleConstants.ORGANIZATION_OWNER);
304
305 userGroupRoleLocalService.addUserGroupRoles(
306 userId, group.getGroupId(), new long[] {role.getRoleId()});
307
308
309
310 addOrganizationResources(userId, organization);
311
312
313
314 if (serviceContext != null) {
315 updateAsset(
316 userId, organization, serviceContext.getAssetCategoryIds(),
317 serviceContext.getAssetTagNames());
318 }
319
320
321
322 if ((serviceContext == null) || serviceContext.isIndexingEnabled()) {
323 Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
324 Organization.class);
325
326 indexer.reindex(organization);
327 }
328
329 return organization;
330 }
331
332
341 @Override
342 public void addOrganizationResources(long userId, Organization organization)
343 throws PortalException, SystemException {
344
345 String name = Organization.class.getName();
346
347 resourceLocalService.addResources(
348 organization.getCompanyId(), 0, userId, name,
349 organization.getOrganizationId(), false, false, false);
350 }
351
352
360 @Override
361 public void addPasswordPolicyOrganizations(
362 long passwordPolicyId, long[] organizationIds)
363 throws SystemException {
364
365 passwordPolicyRelLocalService.addPasswordPolicyRels(
366 passwordPolicyId, Organization.class.getName(), organizationIds);
367 }
368
369
378 @Override
379 public void deleteLogo(long organizationId)
380 throws PortalException, SystemException {
381
382 Organization organization = getOrganization(organizationId);
383
384 Group group = organization.getGroup();
385
386 LayoutSet publicLayoutSet = layoutSetLocalService.getLayoutSet(
387 group.getGroupId(), false);
388
389 if (publicLayoutSet.isLogo()) {
390 long logoId = publicLayoutSet.getLogoId();
391
392 publicLayoutSet.setLogo(false);
393 publicLayoutSet.setLogoId(0);
394
395 layoutSetPersistence.update(publicLayoutSet);
396
397 imageLocalService.deleteImage(logoId);
398 }
399
400 LayoutSet privateLayoutSet = layoutSetLocalService.getLayoutSet(
401 group.getGroupId(), true);
402
403 if (privateLayoutSet.isLogo()) {
404 long logoId = privateLayoutSet.getLogoId();
405
406 privateLayoutSet.setLogo(false);
407 privateLayoutSet.setLogoId(0);
408
409 layoutSetPersistence.update(privateLayoutSet);
410
411 if (imageLocalService.getImage(logoId) != null) {
412 imageLocalService.deleteImage(logoId);
413 }
414 }
415 }
416
417
428 @Override
429 public Organization deleteOrganization(long organizationId)
430 throws PortalException, SystemException {
431
432 Organization organization = organizationPersistence.findByPrimaryKey(
433 organizationId);
434
435 return deleteOrganization(organization);
436 }
437
438
448 @Override
449 public Organization deleteOrganization(Organization organization)
450 throws PortalException, SystemException {
451
452 if ((userLocalService.getOrganizationUsersCount(
453 organization.getOrganizationId(),
454 WorkflowConstants.STATUS_APPROVED) > 0) ||
455 (organizationPersistence.countByC_P(
456 organization.getCompanyId(),
457 organization.getOrganizationId()) > 0)) {
458
459 throw new RequiredOrganizationException();
460 }
461
462
463
464 assetEntryLocalService.deleteEntry(
465 Organization.class.getName(), organization.getOrganizationId());
466
467
468
469 addressLocalService.deleteAddresses(
470 organization.getCompanyId(), Organization.class.getName(),
471 organization.getOrganizationId());
472
473
474
475 emailAddressLocalService.deleteEmailAddresses(
476 organization.getCompanyId(), Organization.class.getName(),
477 organization.getOrganizationId());
478
479
480
481 expandoRowLocalService.deleteRows(organization.getOrganizationId());
482
483
484
485 passwordPolicyRelLocalService.deletePasswordPolicyRel(
486 Organization.class.getName(), organization.getOrganizationId());
487
488
489
490 phoneLocalService.deletePhones(
491 organization.getCompanyId(), Organization.class.getName(),
492 organization.getOrganizationId());
493
494
495
496 websiteLocalService.deleteWebsites(
497 organization.getCompanyId(), Organization.class.getName(),
498 organization.getOrganizationId());
499
500
501
502 Group group = organization.getGroup();
503
504 if (group.isSite()) {
505 group.setSite(false);
506
507 groupPersistence.update(group);
508 }
509
510 groupLocalService.deleteGroup(group);
511
512
513
514 String name = Organization.class.getName();
515
516 resourceLocalService.deleteResource(
517 organization.getCompanyId(), name,
518 ResourceConstants.SCOPE_INDIVIDUAL,
519 organization.getOrganizationId());
520
521
522
523 organizationPersistence.remove(organization);
524
525
526
527 PermissionCacheUtil.clearCache();
528
529 return organization;
530 }
531
532 @Override
533 public Organization fetchOrganization(long companyId, String name)
534 throws SystemException {
535
536 return organizationPersistence.fetchByC_N(companyId, name);
537 }
538
539 @Override
540 public List<Organization> getNoAssetOrganizations() throws SystemException {
541 return organizationFinder.findByNoAssets();
542 }
543
544
554 @Override
555 public Organization getOrganization(long companyId, String name)
556 throws PortalException, SystemException {
557
558 return organizationPersistence.findByC_N(companyId, name);
559 }
560
561
570 @Override
571 public long getOrganizationId(long companyId, String name)
572 throws SystemException {
573
574 Organization organization = organizationPersistence.fetchByC_N(
575 companyId, name);
576
577 if (organization != null) {
578 return organization.getOrganizationId();
579 }
580 else {
581 return 0;
582 }
583 }
584
585 @Override
586 public List<Organization> getOrganizations(
587 long userId, int start, int end, OrderByComparator obc)
588 throws PortalException, SystemException {
589
590 User user = userPersistence.findByPrimaryKey(userId);
591
592 List<Organization> organizations = ListUtil.copy(
593 userPersistence.getOrganizations(userId));
594
595 Iterator<Organization> iterator = organizations.iterator();
596
597 while (iterator.hasNext()) {
598 Organization organization = iterator.next();
599
600 if (organization.getCompanyId() != user.getCompanyId()) {
601 iterator.remove();
602 }
603 }
604
605 if (organizations.isEmpty()) {
606 return organizations;
607 }
608
609 if (obc == null) {
610 obc = new OrganizationNameComparator(true);
611 }
612
613 Collections.sort(organizations, obc);
614
615 return ListUtil.subList(organizations, start, end);
616 }
617
618
627 @Override
628 public List<Organization> getOrganizations(
629 long companyId, long parentOrganizationId)
630 throws SystemException {
631
632 return getOrganizations(
633 companyId, parentOrganizationId, QueryUtil.ALL_POS,
634 QueryUtil.ALL_POS);
635 }
636
637
662 @Override
663 public List<Organization> getOrganizations(
664 long companyId, long parentOrganizationId, int start, int end)
665 throws SystemException {
666
667 if (parentOrganizationId ==
668 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
669
670 return organizationPersistence.findByCompanyId(
671 companyId, start, end);
672 }
673 else {
674 return organizationPersistence.findByC_P(
675 companyId, parentOrganizationId, start, end);
676 }
677 }
678
679
688 @Override
689 public List<Organization> getOrganizations(long[] organizationIds)
690 throws PortalException, SystemException {
691
692 List<Organization> organizations = new ArrayList<Organization>(
693 organizationIds.length);
694
695 for (long organizationId : organizationIds) {
696 Organization organization = getOrganization(organizationId);
697
698 organizations.add(organization);
699 }
700
701 return organizations;
702 }
703
704
713 @Override
714 public int getOrganizationsCount(long companyId, long parentOrganizationId)
715 throws SystemException {
716
717 if (parentOrganizationId ==
718 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
719
720 return organizationPersistence.countByCompanyId(companyId);
721 }
722 else {
723 return organizationPersistence.countByC_P(
724 companyId, parentOrganizationId);
725 }
726 }
727
728
738 @Override
739 public List<Organization> getParentOrganizations(long organizationId)
740 throws PortalException, SystemException {
741
742 if (organizationId ==
743 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
744
745 return new ArrayList<Organization>();
746 }
747
748 Organization organization = organizationPersistence.findByPrimaryKey(
749 organizationId);
750
751 return organization.getAncestors();
752 }
753
754
762 @Override
763 public List<Organization> getSuborganizations(
764 List<Organization> organizations)
765 throws SystemException {
766
767 List<Organization> allSuborganizations = new ArrayList<Organization>();
768
769 for (int i = 0; i < organizations.size(); i++) {
770 Organization organization = organizations.get(i);
771
772 List<Organization> suborganizations =
773 organizationPersistence.findByC_P(
774 organization.getCompanyId(),
775 organization.getOrganizationId());
776
777 addSuborganizations(allSuborganizations, suborganizations);
778 }
779
780 return allSuborganizations;
781 }
782
783
791 @Override
792 public List<Organization> getSuborganizations(
793 long companyId, long organizationId)
794 throws SystemException {
795
796 return organizationPersistence.findByC_P(companyId, organizationId);
797 }
798
799
807 @Override
808 public int getSuborganizationsCount(long companyId, long organizationId)
809 throws SystemException {
810
811 return organizationPersistence.countByC_P(companyId, organizationId);
812 }
813
814
823 @Override
824 public List<Organization> getSubsetOrganizations(
825 List<Organization> allOrganizations,
826 List<Organization> availableOrganizations) {
827
828 List<Organization> subsetOrganizations = new ArrayList<Organization>();
829
830 for (Organization organization : allOrganizations) {
831 if (availableOrganizations.contains(organization)) {
832 subsetOrganizations.add(organization);
833 }
834 }
835
836 return subsetOrganizations;
837 }
838
839
853 @Override
854 public List<Organization> getUserOrganizations(
855 long userId, boolean includeAdministrative)
856 throws PortalException, SystemException {
857
858 if (!includeAdministrative) {
859 return getUserOrganizations(userId);
860 }
861
862 Set<Organization> organizations = new HashSet<Organization>();
863
864 List<UserGroupRole> userGroupRoles =
865 userGroupRoleLocalService.getUserGroupRoles(userId);
866
867 for (UserGroupRole userGroupRole : userGroupRoles) {
868 Role role = userGroupRole.getRole();
869
870 String roleName = role.getName();
871
872 if (roleName.equals(RoleConstants.ORGANIZATION_ADMINISTRATOR) ||
873 roleName.equals(RoleConstants.ORGANIZATION_OWNER)) {
874
875 Group group = userGroupRole.getGroup();
876
877 Organization organization =
878 organizationPersistence.findByPrimaryKey(
879 group.getOrganizationId());
880
881 organizations.add(organization);
882 }
883 }
884
885 organizations.addAll(getUserOrganizations(userId));
886
887 return new ArrayList<Organization>(organizations);
888 }
889
890
900 @Override
901 public boolean hasPasswordPolicyOrganization(
902 long passwordPolicyId, long organizationId)
903 throws SystemException {
904
905 return passwordPolicyRelLocalService.hasPasswordPolicyRel(
906 passwordPolicyId, Organization.class.getName(), organizationId);
907 }
908
909
958 @Override
959 public boolean hasUserOrganization(
960 long userId, long organizationId, boolean inheritSuborganizations,
961 boolean includeSpecifiedOrganization)
962 throws PortalException, SystemException {
963
964 if (!inheritSuborganizations) {
965 return userPersistence.containsOrganization(userId, organizationId);
966 }
967
968 LinkedHashMap<String, Object> params =
969 new LinkedHashMap<String, Object>();
970
971 List<Organization> organizationsTree = new ArrayList<Organization>();
972
973 Organization organization = organizationPersistence.findByPrimaryKey(
974 organizationId);
975
976 if (!includeSpecifiedOrganization) {
977 organizationsTree.add(organization);
978 }
979 else {
980 organizationsTree.add(organization.getParentOrganization());
981 }
982
983 params.put("usersOrgsTree", organizationsTree);
984
985 if (userFinder.countByUser(userId, params) > 0) {
986 return true;
987 }
988
989 return false;
990 }
991
992
1006 @Override
1007 public void rebuildTree(long companyId)
1008 throws PortalException, SystemException {
1009
1010 TreePathUtil.rebuildTree(
1011 companyId, OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID,
1012 new TreeModelFinder<Organization>() {
1013
1014 @Override
1015 public List<Organization> findTreeModels(
1016 long previousId, long companyId, long parentPrimaryKey,
1017 int size)
1018 throws SystemException {
1019
1020 return organizationPersistence.findByO_C_P(
1021 previousId, companyId, parentPrimaryKey,
1022 QueryUtil.ALL_POS, size,
1023 new OrganizationIdComparator());
1024 }
1025
1026 }
1027 );
1028 }
1029
1030
1063 @Override
1064 public Hits search(
1065 long companyId, long parentOrganizationId, String keywords,
1066 LinkedHashMap<String, Object> params, int start, int end, Sort sort)
1067 throws SystemException {
1068
1069 String name = null;
1070 String type = null;
1071 String street = null;
1072 String city = null;
1073 String zip = null;
1074 String region = null;
1075 String country = null;
1076 boolean andOperator = false;
1077
1078 if (Validator.isNotNull(keywords)) {
1079 name = keywords;
1080 type = keywords;
1081 street = keywords;
1082 city = keywords;
1083 zip = keywords;
1084 region = keywords;
1085 country = keywords;
1086 }
1087 else {
1088 andOperator = true;
1089 }
1090
1091 if (params != null) {
1092 params.put("keywords", keywords);
1093 }
1094
1095 return search(
1096 companyId, parentOrganizationId, name, type, street, city, zip,
1097 region, country, params, andOperator, start, end, sort);
1098 }
1099
1100
1137 @Override
1138 public List<Organization> search(
1139 long companyId, long parentOrganizationId, String keywords,
1140 String type, Long regionId, Long countryId,
1141 LinkedHashMap<String, Object> params, int start, int end)
1142 throws SystemException {
1143
1144 return search(
1145 companyId, parentOrganizationId, keywords, type, regionId,
1146 countryId, params, start, end,
1147 new OrganizationNameComparator(true));
1148 }
1149
1150
1190 @Override
1191 public List<Organization> search(
1192 long companyId, long parentOrganizationId, String keywords,
1193 String type, Long regionId, Long countryId,
1194 LinkedHashMap<String, Object> params, int start, int end,
1195 OrderByComparator obc)
1196 throws SystemException {
1197
1198 String parentOrganizationIdComparator = StringPool.EQUAL;
1199
1200 if (parentOrganizationId ==
1201 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1202
1203 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1204 }
1205
1206 return organizationFinder.findByKeywords(
1207 companyId, parentOrganizationId, parentOrganizationIdComparator,
1208 keywords, type, regionId, countryId, params, start, end, obc);
1209 }
1210
1211
1255 @Override
1256 public List<Organization> search(
1257 long companyId, long parentOrganizationId, String name, String type,
1258 String street, String city, String zip, Long regionId,
1259 Long countryId, LinkedHashMap<String, Object> params,
1260 boolean andOperator, int start, int end)
1261 throws SystemException {
1262
1263 return search(
1264 companyId, parentOrganizationId, name, type, street, city, zip,
1265 regionId, countryId, params, andOperator, start, end,
1266 new OrganizationNameComparator(true));
1267 }
1268
1269
1316 @Override
1317 public List<Organization> search(
1318 long companyId, long parentOrganizationId, String name, String type,
1319 String street, String city, String zip, Long regionId,
1320 Long countryId, LinkedHashMap<String, Object> params,
1321 boolean andOperator, int start, int end, OrderByComparator obc)
1322 throws SystemException {
1323
1324 String parentOrganizationIdComparator = StringPool.EQUAL;
1325
1326 if (parentOrganizationId ==
1327 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1328
1329 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1330 }
1331
1332 return organizationFinder.findByC_PO_N_T_S_C_Z_R_C(
1333 companyId, parentOrganizationId, parentOrganizationIdComparator,
1334 name, type, street, city, zip, regionId, countryId, params,
1335 andOperator, start, end, obc);
1336 }
1337
1338
1379 @Override
1380 public Hits search(
1381 long companyId, long parentOrganizationId, String name, String type,
1382 String street, String city, String zip, String region,
1383 String country, LinkedHashMap<String, Object> params,
1384 boolean andSearch, int start, int end, Sort sort)
1385 throws SystemException {
1386
1387 try {
1388 SearchContext searchContext = new SearchContext();
1389
1390 searchContext.setAndSearch(andSearch);
1391
1392 Map<String, Serializable> attributes =
1393 new HashMap<String, Serializable>();
1394
1395 attributes.put("city", city);
1396 attributes.put("country", country);
1397 attributes.put("name", name);
1398 attributes.put("params", params);
1399 attributes.put(
1400 "parentOrganizationId", String.valueOf(parentOrganizationId));
1401 attributes.put("region", region);
1402 attributes.put("street", street);
1403 attributes.put("type", type);
1404 attributes.put("zip", zip);
1405
1406 searchContext.setAttributes(attributes);
1407
1408 searchContext.setCompanyId(companyId);
1409 searchContext.setEnd(end);
1410
1411 if (params != null) {
1412 String keywords = (String)params.remove("keywords");
1413
1414 if (Validator.isNotNull(keywords)) {
1415 searchContext.setKeywords(keywords);
1416 }
1417 }
1418
1419 QueryConfig queryConfig = new QueryConfig();
1420
1421 queryConfig.setHighlightEnabled(false);
1422 queryConfig.setScoreEnabled(false);
1423
1424 searchContext.setQueryConfig(queryConfig);
1425
1426 if (sort != null) {
1427 searchContext.setSorts(sort);
1428 }
1429
1430 searchContext.setStart(start);
1431
1432 Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1433 Organization.class);
1434
1435 return indexer.search(searchContext);
1436 }
1437 catch (Exception e) {
1438 throw new SystemException(e);
1439 }
1440 }
1441
1442
1464 @Override
1465 public int searchCount(
1466 long companyId, long parentOrganizationId, String keywords,
1467 String type, Long regionId, Long countryId,
1468 LinkedHashMap<String, Object> params)
1469 throws SystemException {
1470
1471 String parentOrganizationIdComparator = StringPool.EQUAL;
1472
1473 if (parentOrganizationId ==
1474 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1475
1476 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1477 }
1478
1479 return organizationFinder.countByKeywords(
1480 companyId, parentOrganizationId, parentOrganizationIdComparator,
1481 keywords, type, regionId, countryId, params);
1482 }
1483
1484
1513 @Override
1514 public int searchCount(
1515 long companyId, long parentOrganizationId, String name, String type,
1516 String street, String city, String zip, Long regionId,
1517 Long countryId, LinkedHashMap<String, Object> params,
1518 boolean andOperator)
1519 throws SystemException {
1520
1521 String parentOrganizationIdComparator = StringPool.EQUAL;
1522
1523 if (parentOrganizationId ==
1524 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1525
1526 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1527 }
1528
1529 return organizationFinder.countByC_PO_N_T_S_C_Z_R_C(
1530 companyId, parentOrganizationId, parentOrganizationIdComparator,
1531 name, type, street, city, zip, regionId, countryId, params,
1532 andOperator);
1533 }
1534
1535
1544 @Override
1545 public void setGroupOrganizations(long groupId, long[] organizationIds)
1546 throws PortalException, SystemException {
1547
1548 groupPersistence.setOrganizations(groupId, organizationIds);
1549
1550 PermissionCacheUtil.clearCache();
1551 }
1552
1553
1561 @Override
1562 public void unsetGroupOrganizations(long groupId, long[] organizationIds)
1563 throws PortalException, SystemException {
1564
1565 groupPersistence.removeOrganizations(groupId, organizationIds);
1566
1567 PermissionCacheUtil.clearCache();
1568 }
1569
1570
1577 @Override
1578 public void unsetPasswordPolicyOrganizations(
1579 long passwordPolicyId, long[] organizationIds)
1580 throws SystemException {
1581
1582 passwordPolicyRelLocalService.deletePasswordPolicyRels(
1583 passwordPolicyId, Organization.class.getName(), organizationIds);
1584 }
1585
1586
1597 @Override
1598 public void updateAsset(
1599 long userId, Organization organization, long[] assetCategoryIds,
1600 String[] assetTagNames)
1601 throws PortalException, SystemException {
1602
1603 User user = userPersistence.findByPrimaryKey(userId);
1604
1605 Company company = companyPersistence.findByPrimaryKey(
1606 user.getCompanyId());
1607
1608 Group companyGroup = company.getGroup();
1609
1610 assetEntryLocalService.updateEntry(
1611 userId, companyGroup.getGroupId(), null, null,
1612 Organization.class.getName(), organization.getOrganizationId(),
1613 organization.getUuid(), 0, assetCategoryIds, assetTagNames, false,
1614 null, null, null, null, organization.getName(), StringPool.BLANK,
1615 null, null, null, 0, 0, null, false);
1616 }
1617
1618
1648 @Override
1649 public Organization updateOrganization(
1650 long companyId, long organizationId, long parentOrganizationId,
1651 String name, String type, boolean recursable, long regionId,
1652 long countryId, int statusId, String comments, boolean site,
1653 ServiceContext serviceContext)
1654 throws PortalException, SystemException {
1655
1656 return updateOrganization(
1657 companyId, organizationId, parentOrganizationId, name, type,
1658 regionId, countryId, statusId, comments, site, serviceContext);
1659 }
1660
1661
1686 @Override
1687 public Organization updateOrganization(
1688 long companyId, long organizationId, long parentOrganizationId,
1689 String name, String type, long regionId, long countryId,
1690 int statusId, String comments, boolean site,
1691 ServiceContext serviceContext)
1692 throws PortalException, SystemException {
1693
1694
1695
1696 parentOrganizationId = getParentOrganizationId(
1697 companyId, parentOrganizationId);
1698
1699 validate(
1700 companyId, organizationId, parentOrganizationId, name, type,
1701 countryId, statusId);
1702
1703 Organization organization = organizationPersistence.findByPrimaryKey(
1704 organizationId);
1705
1706 long oldParentOrganizationId = organization.getParentOrganizationId();
1707 String oldName = organization.getName();
1708
1709 organization.setModifiedDate(new Date());
1710 organization.setParentOrganizationId(parentOrganizationId);
1711 organization.setTreePath(organization.buildTreePath());
1712 organization.setName(name);
1713 organization.setType(type);
1714 organization.setRecursable(true);
1715 organization.setRegionId(regionId);
1716 organization.setCountryId(countryId);
1717 organization.setStatusId(statusId);
1718 organization.setComments(comments);
1719 organization.setExpandoBridgeAttributes(serviceContext);
1720
1721 organizationPersistence.update(organization);
1722
1723
1724
1725 Group group = organization.getGroup();
1726
1727 long parentGroupId = group.getParentGroupId();
1728
1729 boolean organizationGroup = isOrganizationGroup(
1730 oldParentOrganizationId, group.getParentGroupId());
1731
1732 if (organizationGroup) {
1733 if (parentOrganizationId !=
1734 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1735
1736 Organization parentOrganization =
1737 organizationPersistence.fetchByPrimaryKey(
1738 parentOrganizationId);
1739
1740 Group parentGroup = parentOrganization.getGroup();
1741
1742 if (site && parentGroup.isSite()) {
1743 parentGroupId = parentOrganization.getGroupId();
1744 }
1745 else {
1746 parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
1747 }
1748 }
1749 else {
1750 parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
1751 }
1752 }
1753
1754 if (!oldName.equals(name) || organizationGroup) {
1755 groupLocalService.updateGroup(
1756 group.getGroupId(), parentGroupId, name, group.getDescription(),
1757 group.getType(), group.isManualMembership(),
1758 group.getMembershipRestriction(), group.getFriendlyURL(),
1759 group.isActive(), null);
1760 }
1761
1762 if (group.isSite() != site) {
1763 groupLocalService.updateSite(group.getGroupId(), site);
1764 }
1765
1766
1767
1768 if (serviceContext != null) {
1769 updateAsset(
1770 serviceContext.getUserId(), organization,
1771 serviceContext.getAssetCategoryIds(),
1772 serviceContext.getAssetTagNames());
1773 }
1774
1775
1776
1777 Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1778 Organization.class);
1779
1780 if (oldParentOrganizationId != parentOrganizationId) {
1781 long[] organizationIds = getReindexOrganizationIds(organization);
1782
1783 indexer.reindex(organizationIds);
1784 }
1785 else {
1786 indexer.reindex(organization);
1787 }
1788
1789 return organization;
1790 }
1791
1792 protected void addSuborganizations(
1793 List<Organization> allSuborganizations,
1794 List<Organization> organizations)
1795 throws SystemException {
1796
1797 for (Organization organization : organizations) {
1798 if (!allSuborganizations.contains(organization)) {
1799 allSuborganizations.add(organization);
1800
1801 List<Organization> suborganizations =
1802 organizationPersistence.findByC_P(
1803 organization.getCompanyId(),
1804 organization.getOrganizationId());
1805
1806 addSuborganizations(allSuborganizations, suborganizations);
1807 }
1808 }
1809 }
1810
1811 protected long getParentOrganizationId(
1812 long companyId, long parentOrganizationId)
1813 throws SystemException {
1814
1815 if (parentOrganizationId !=
1816 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1817
1818
1819
1820
1821 Organization parentOrganization =
1822 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
1823
1824 if ((parentOrganization == null) ||
1825 (companyId != parentOrganization.getCompanyId())) {
1826
1827 parentOrganizationId =
1828 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID;
1829 }
1830 }
1831
1832 return parentOrganizationId;
1833 }
1834
1835 protected long[] getReindexOrganizationIds(Organization organization)
1836 throws PortalException, SystemException {
1837
1838 List<Organization> organizations = organizationPersistence.findByC_T(
1839 organization.getCompanyId(),
1840 CustomSQLUtil.keywords(organization.getTreePath())[0],
1841 QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1842 new OrganizationNameComparator(true));
1843
1844 long[] organizationIds = new long[organizations.size()];
1845
1846 for (int i = 0; i < organizations.size(); i++) {
1847 Organization curOrganization = organizations.get(i);
1848
1849 curOrganization.setTreePath(curOrganization.buildTreePath());
1850
1851 organizationPersistence.update(curOrganization);
1852
1853 organizationIds[i] = curOrganization.getOrganizationId();
1854 }
1855
1856 if (!ArrayUtil.contains(
1857 organizationIds, organization.getOrganizationId())) {
1858
1859 organizationIds = ArrayUtil.append(
1860 organizationIds, organization.getOrganizationId());
1861 }
1862
1863 return organizationIds;
1864 }
1865
1866 protected boolean isOrganizationGroup(long organizationId, long groupId)
1867 throws SystemException {
1868
1869 if ((organizationId ==
1870 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) &&
1871 (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
1872
1873 return true;
1874 }
1875
1876 if (organizationId !=
1877 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1878
1879 Organization organization =
1880 organizationPersistence.fetchByPrimaryKey(organizationId);
1881
1882 if (organization.getGroupId() == groupId) {
1883 return true;
1884 }
1885 }
1886
1887 return false;
1888 }
1889
1890 protected boolean isParentOrganization(
1891 long parentOrganizationId, long organizationId)
1892 throws PortalException, SystemException {
1893
1894
1895
1896
1897 if (organizationId ==
1898 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1899
1900 return false;
1901 }
1902
1903 Organization organization = organizationPersistence.findByPrimaryKey(
1904 organizationId);
1905
1906 String treePath = organization.getTreePath();
1907
1908 if (treePath.contains(
1909 StringPool.SLASH + parentOrganizationId + StringPool.SLASH)) {
1910
1911 return true;
1912 }
1913 else {
1914 return false;
1915 }
1916 }
1917
1918 protected void validate(
1919 long companyId, long organizationId, long parentOrganizationId,
1920 String name, String type, long countryId, int statusId)
1921 throws PortalException, SystemException {
1922
1923 if (!ArrayUtil.contains(PropsValues.ORGANIZATIONS_TYPES, type)) {
1924 throw new OrganizationTypeException(
1925 "Invalid organization type " + type);
1926 }
1927
1928 if (parentOrganizationId ==
1929 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1930
1931 if (!OrganizationImpl.isRootable(type)) {
1932 throw new OrganizationParentException(
1933 "Organization of type " + type + " cannot be a root");
1934 }
1935 }
1936 else {
1937 Organization parentOrganization =
1938 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
1939
1940 if (parentOrganization == null) {
1941 throw new OrganizationParentException(
1942 "Organization " + parentOrganizationId + " doesn't exist");
1943 }
1944
1945 String[] childrenTypes = OrganizationImpl.getChildrenTypes(
1946 parentOrganization.getType());
1947
1948 if (childrenTypes.length == 0) {
1949 throw new OrganizationParentException(
1950 "Organization of type " + type + " cannot have children");
1951 }
1952
1953 if ((companyId != parentOrganization.getCompanyId()) ||
1954 (parentOrganizationId == organizationId)) {
1955
1956 throw new OrganizationParentException();
1957 }
1958
1959 if (!ArrayUtil.contains(childrenTypes, type)) {
1960 throw new OrganizationParentException(
1961 "Type " + type + " not allowed as child of " +
1962 parentOrganization.getType());
1963 }
1964 }
1965
1966 if ((organizationId > 0) &&
1967 (parentOrganizationId !=
1968 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID)) {
1969
1970
1971
1972 if (isParentOrganization(organizationId, parentOrganizationId)) {
1973 throw new OrganizationParentException();
1974 }
1975 }
1976
1977 if (Validator.isNull(name)) {
1978 throw new OrganizationNameException();
1979 }
1980 else {
1981 Organization organization = organizationPersistence.fetchByC_N(
1982 companyId, name);
1983
1984 if ((organization != null) &&
1985 StringUtil.equalsIgnoreCase(organization.getName(), name)) {
1986
1987 if ((organizationId <= 0) ||
1988 (organization.getOrganizationId() != organizationId)) {
1989
1990 throw new DuplicateOrganizationException(
1991 "There is another organization named " + name);
1992 }
1993 }
1994 }
1995
1996 boolean countryRequired = GetterUtil.getBoolean(
1997 PropsUtil.get(
1998 PropsKeys.ORGANIZATIONS_COUNTRY_REQUIRED, new Filter(type)));
1999
2000 if (countryRequired || (countryId > 0)) {
2001 countryPersistence.findByPrimaryKey(countryId);
2002 }
2003
2004 listTypeService.validate(
2005 statusId, ListTypeConstants.ORGANIZATION_STATUS);
2006 }
2007
2008 protected void validate(
2009 long companyId, long parentOrganizationId, String name, String type,
2010 long countryId, int statusId)
2011 throws PortalException, SystemException {
2012
2013 validate(
2014 companyId, 0, parentOrganizationId, name, type, countryId,
2015 statusId);
2016 }
2017
2018 }