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.Validator;
040 import com.liferay.portal.kernel.workflow.WorkflowConstants;
041 import com.liferay.portal.model.Company;
042 import com.liferay.portal.model.Group;
043 import com.liferay.portal.model.GroupConstants;
044 import com.liferay.portal.model.LayoutSet;
045 import com.liferay.portal.model.ListTypeConstants;
046 import com.liferay.portal.model.Organization;
047 import com.liferay.portal.model.OrganizationConstants;
048 import com.liferay.portal.model.ResourceConstants;
049 import com.liferay.portal.model.Role;
050 import com.liferay.portal.model.RoleConstants;
051 import com.liferay.portal.model.User;
052 import com.liferay.portal.model.UserGroupRole;
053 import com.liferay.portal.model.impl.OrganizationImpl;
054 import com.liferay.portal.security.permission.PermissionCacheUtil;
055 import com.liferay.portal.service.ServiceContext;
056 import com.liferay.portal.service.base.OrganizationLocalServiceBaseImpl;
057 import com.liferay.portal.util.PropsUtil;
058 import com.liferay.portal.util.PropsValues;
059 import com.liferay.portal.util.comparator.OrganizationNameComparator;
060
061 import java.io.Serializable;
062
063 import java.util.ArrayList;
064 import java.util.Collections;
065 import java.util.Date;
066 import java.util.HashMap;
067 import java.util.HashSet;
068 import java.util.Iterator;
069 import java.util.LinkedHashMap;
070 import java.util.List;
071 import java.util.Map;
072 import java.util.Set;
073
074
084 public class OrganizationLocalServiceImpl
085 extends OrganizationLocalServiceBaseImpl {
086
087
096 @Override
097 public void addGroupOrganizations(long groupId, long[] organizationIds)
098 throws PortalException, SystemException {
099
100 groupPersistence.addOrganizations(groupId, organizationIds);
101
102 PermissionCacheUtil.clearCache();
103 }
104
105
127 @Override
128 public Organization addOrganization(
129 long userId, long parentOrganizationId, String name, boolean site)
130 throws PortalException, SystemException {
131
132 return addOrganization(
133 userId, parentOrganizationId, name,
134 OrganizationConstants.TYPE_REGULAR_ORGANIZATION, 0, 0,
135 ListTypeConstants.ORGANIZATION_STATUS_DEFAULT, StringPool.BLANK,
136 site, null);
137 }
138
139
175 @Override
176 public Organization addOrganization(
177 long userId, long parentOrganizationId, String name, String type,
178 boolean recursable, long regionId, long countryId, int statusId,
179 String comments, boolean site, ServiceContext serviceContext)
180 throws PortalException, SystemException {
181
182 return addOrganization(
183 userId, parentOrganizationId, name, type, regionId, countryId,
184 statusId, comments, site, serviceContext);
185 }
186
187
217 @Override
218 public Organization addOrganization(
219 long userId, long parentOrganizationId, String name, String type,
220 long regionId, long countryId, int statusId, String comments,
221 boolean site, ServiceContext serviceContext)
222 throws PortalException, SystemException {
223
224
225
226 User user = userPersistence.findByPrimaryKey(userId);
227 parentOrganizationId = getParentOrganizationId(
228 user.getCompanyId(), parentOrganizationId);
229 Date now = new Date();
230
231 validate(
232 user.getCompanyId(), parentOrganizationId, name, type, countryId,
233 statusId);
234
235 long organizationId = counterLocalService.increment();
236
237 Organization organization = organizationPersistence.create(
238 organizationId);
239
240 if (serviceContext != null) {
241 organization.setUuid(serviceContext.getUuid());
242 }
243
244 organization.setCompanyId(user.getCompanyId());
245 organization.setUserId(user.getUserId());
246 organization.setUserName(user.getFullName());
247
248 if (serviceContext != null) {
249 organization.setCreateDate(serviceContext.getCreateDate(now));
250 organization.setModifiedDate(serviceContext.getModifiedDate(now));
251 }
252 else {
253 organization.setCreateDate(now);
254 organization.setModifiedDate(now);
255 }
256
257 organization.setParentOrganizationId(parentOrganizationId);
258 organization.setTreePath(organization.buildTreePath());
259 organization.setName(name);
260 organization.setType(type);
261 organization.setRecursable(true);
262 organization.setRegionId(regionId);
263 organization.setCountryId(countryId);
264 organization.setStatusId(statusId);
265 organization.setComments(comments);
266 organization.setExpandoBridgeAttributes(serviceContext);
267
268 organizationPersistence.update(organization);
269
270
271
272 long parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
273
274 if (parentOrganizationId !=
275 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
276
277 Organization parentOrganization =
278 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
279
280 if (parentOrganization != null) {
281 Group parentGroup = parentOrganization.getGroup();
282
283 if (site && parentGroup.isSite()) {
284 parentGroupId = parentOrganization.getGroupId();
285 }
286 }
287 }
288
289 Group group = groupLocalService.addGroup(
290 userId, parentGroupId, Organization.class.getName(), organizationId,
291 GroupConstants.DEFAULT_LIVE_GROUP_ID, name, null,
292 GroupConstants.TYPE_SITE_PRIVATE, false,
293 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, null, site, true,
294 null);
295
296
297
298 Role role = roleLocalService.getRole(
299 organization.getCompanyId(), RoleConstants.ORGANIZATION_OWNER);
300
301 userGroupRoleLocalService.addUserGroupRoles(
302 userId, group.getGroupId(), new long[] {role.getRoleId()});
303
304
305
306 addOrganizationResources(userId, organization);
307
308
309
310 if (serviceContext != null) {
311 updateAsset(
312 userId, organization, serviceContext.getAssetCategoryIds(),
313 serviceContext.getAssetTagNames());
314 }
315
316
317
318 if ((serviceContext == null) || serviceContext.isIndexingEnabled()) {
319 Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
320 Organization.class);
321
322 indexer.reindex(organization);
323 }
324
325 return organization;
326 }
327
328
337 @Override
338 public void addOrganizationResources(long userId, Organization organization)
339 throws PortalException, SystemException {
340
341 String name = Organization.class.getName();
342
343 resourceLocalService.addResources(
344 organization.getCompanyId(), 0, userId, name,
345 organization.getOrganizationId(), false, false, false);
346 }
347
348
356 @Override
357 public void addPasswordPolicyOrganizations(
358 long passwordPolicyId, long[] organizationIds)
359 throws SystemException {
360
361 passwordPolicyRelLocalService.addPasswordPolicyRels(
362 passwordPolicyId, Organization.class.getName(), organizationIds);
363 }
364
365
374 @Override
375 public void deleteLogo(long organizationId)
376 throws PortalException, SystemException {
377
378 Organization organization = getOrganization(organizationId);
379
380 Group group = organization.getGroup();
381
382 LayoutSet publicLayoutSet = layoutSetLocalService.getLayoutSet(
383 group.getGroupId(), false);
384
385 if (publicLayoutSet.isLogo()) {
386 long logoId = publicLayoutSet.getLogoId();
387
388 publicLayoutSet.setLogo(false);
389 publicLayoutSet.setLogoId(0);
390
391 layoutSetPersistence.update(publicLayoutSet);
392
393 imageLocalService.deleteImage(logoId);
394 }
395
396 LayoutSet privateLayoutSet = layoutSetLocalService.getLayoutSet(
397 group.getGroupId(), true);
398
399 if (privateLayoutSet.isLogo()) {
400 long logoId = privateLayoutSet.getLogoId();
401
402 privateLayoutSet.setLogo(false);
403 privateLayoutSet.setLogoId(0);
404
405 layoutSetPersistence.update(privateLayoutSet);
406
407 if (imageLocalService.getImage(logoId) != null) {
408 imageLocalService.deleteImage(logoId);
409 }
410 }
411 }
412
413
424 @Override
425 public Organization deleteOrganization(long organizationId)
426 throws PortalException, SystemException {
427
428 Organization organization = organizationPersistence.findByPrimaryKey(
429 organizationId);
430
431 return deleteOrganization(organization);
432 }
433
434
444 @Override
445 public Organization deleteOrganization(Organization organization)
446 throws PortalException, SystemException {
447
448 if ((userLocalService.getOrganizationUsersCount(
449 organization.getOrganizationId(),
450 WorkflowConstants.STATUS_APPROVED) > 0) ||
451 (organizationPersistence.countByC_P(
452 organization.getCompanyId(),
453 organization.getOrganizationId()) > 0)) {
454
455 throw new RequiredOrganizationException();
456 }
457
458
459
460 assetEntryLocalService.deleteEntry(
461 Organization.class.getName(), organization.getOrganizationId());
462
463
464
465 addressLocalService.deleteAddresses(
466 organization.getCompanyId(), Organization.class.getName(),
467 organization.getOrganizationId());
468
469
470
471 emailAddressLocalService.deleteEmailAddresses(
472 organization.getCompanyId(), Organization.class.getName(),
473 organization.getOrganizationId());
474
475
476
477 expandoRowLocalService.deleteRows(organization.getOrganizationId());
478
479
480
481 passwordPolicyRelLocalService.deletePasswordPolicyRel(
482 Organization.class.getName(), organization.getOrganizationId());
483
484
485
486 phoneLocalService.deletePhones(
487 organization.getCompanyId(), Organization.class.getName(),
488 organization.getOrganizationId());
489
490
491
492 websiteLocalService.deleteWebsites(
493 organization.getCompanyId(), Organization.class.getName(),
494 organization.getOrganizationId());
495
496
497
498 Group group = organization.getGroup();
499
500 if (group.isSite()) {
501 group.setSite(false);
502
503 groupPersistence.update(group);
504 }
505
506 groupLocalService.deleteGroup(group);
507
508
509
510 String name = Organization.class.getName();
511
512 resourceLocalService.deleteResource(
513 organization.getCompanyId(), name,
514 ResourceConstants.SCOPE_INDIVIDUAL,
515 organization.getOrganizationId());
516
517
518
519 organizationPersistence.remove(organization);
520
521
522
523 PermissionCacheUtil.clearCache();
524
525 return organization;
526 }
527
528 @Override
529 public Organization fetchOrganization(long companyId, String name)
530 throws SystemException {
531
532 return organizationPersistence.fetchByC_N(companyId, name);
533 }
534
535 @Override
536 public List<Organization> getNoAssetOrganizations() throws SystemException {
537 return organizationFinder.findByNoAssets();
538 }
539
540
550 @Override
551 public Organization getOrganization(long companyId, String name)
552 throws PortalException, SystemException {
553
554 return organizationPersistence.findByC_N(companyId, name);
555 }
556
557
566 @Override
567 public long getOrganizationId(long companyId, String name)
568 throws SystemException {
569
570 Organization organization = organizationPersistence.fetchByC_N(
571 companyId, name);
572
573 if (organization != null) {
574 return organization.getOrganizationId();
575 }
576 else {
577 return 0;
578 }
579 }
580
581 @Override
582 public List<Organization> getOrganizations(
583 long userId, int start, int end, OrderByComparator obc)
584 throws PortalException, SystemException {
585
586 User user = userPersistence.findByPrimaryKey(userId);
587
588 List<Organization> organizations = ListUtil.copy(
589 userPersistence.getOrganizations(userId));
590
591 Iterator<Organization> iterator = organizations.iterator();
592
593 while (iterator.hasNext()) {
594 Organization organization = iterator.next();
595
596 if ((organization.getCompanyId() != user.getCompanyId()) ||
597 (organization.getParentOrganization() == null)) {
598
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
625 @Override
626 public List<Organization> getOrganizations(
627 long companyId, long parentOrganizationId)
628 throws SystemException {
629
630 return getOrganizations(
631 companyId, parentOrganizationId, QueryUtil.ALL_POS,
632 QueryUtil.ALL_POS);
633 }
634
635
660 @Override
661 public List<Organization> getOrganizations(
662 long companyId, long parentOrganizationId, int start, int end)
663 throws SystemException {
664
665 if (parentOrganizationId ==
666 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
667
668 return organizationPersistence.findByCompanyId(
669 companyId, start, end);
670 }
671 else {
672 return organizationPersistence.findByC_P(
673 companyId, parentOrganizationId, start, end);
674 }
675 }
676
677
686 @Override
687 public List<Organization> getOrganizations(long[] organizationIds)
688 throws PortalException, SystemException {
689
690 List<Organization> organizations = new ArrayList<Organization>(
691 organizationIds.length);
692
693 for (long organizationId : organizationIds) {
694 Organization organization = getOrganization(organizationId);
695
696 organizations.add(organization);
697 }
698
699 return organizations;
700 }
701
702
711 @Override
712 public int getOrganizationsCount(long companyId, long parentOrganizationId)
713 throws SystemException {
714
715 if (parentOrganizationId ==
716 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
717
718 return organizationPersistence.countByCompanyId(companyId);
719 }
720 else {
721 return organizationPersistence.countByC_P(
722 companyId, parentOrganizationId);
723 }
724 }
725
726
736 @Override
737 public List<Organization> getParentOrganizations(long organizationId)
738 throws PortalException, SystemException {
739
740 if (organizationId ==
741 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
742
743 return new ArrayList<Organization>();
744 }
745
746 Organization organization = organizationPersistence.findByPrimaryKey(
747 organizationId);
748
749 return organization.getAncestors();
750 }
751
752
760 @Override
761 public List<Organization> getSuborganizations(
762 List<Organization> organizations)
763 throws SystemException {
764
765 List<Organization> allSuborganizations = new ArrayList<Organization>();
766
767 for (int i = 0; i < organizations.size(); i++) {
768 Organization organization = organizations.get(i);
769
770 List<Organization> suborganizations =
771 organizationPersistence.findByC_P(
772 organization.getCompanyId(),
773 organization.getOrganizationId());
774
775 addSuborganizations(allSuborganizations, suborganizations);
776 }
777
778 return allSuborganizations;
779 }
780
781
789 @Override
790 public List<Organization> getSuborganizations(
791 long companyId, long organizationId)
792 throws SystemException {
793
794 return organizationPersistence.findByC_P(companyId, organizationId);
795 }
796
797
805 @Override
806 public int getSuborganizationsCount(long companyId, long organizationId)
807 throws SystemException {
808
809 return organizationPersistence.countByC_P(companyId, organizationId);
810 }
811
812
821 @Override
822 public List<Organization> getSubsetOrganizations(
823 List<Organization> allOrganizations,
824 List<Organization> availableOrganizations) {
825
826 List<Organization> subsetOrganizations = new ArrayList<Organization>();
827
828 for (Organization organization : allOrganizations) {
829 if (availableOrganizations.contains(organization)) {
830 subsetOrganizations.add(organization);
831 }
832 }
833
834 return subsetOrganizations;
835 }
836
837
851 @Override
852 public List<Organization> getUserOrganizations(
853 long userId, boolean includeAdministrative)
854 throws PortalException, SystemException {
855
856 if (!includeAdministrative) {
857 return getUserOrganizations(userId);
858 }
859
860 Set<Organization> organizations = new HashSet<Organization>();
861
862 List<UserGroupRole> userGroupRoles =
863 userGroupRoleLocalService.getUserGroupRoles(userId);
864
865 for (UserGroupRole userGroupRole : userGroupRoles) {
866 Role role = userGroupRole.getRole();
867
868 String roleName = role.getName();
869
870 if (roleName.equals(RoleConstants.ORGANIZATION_ADMINISTRATOR) ||
871 roleName.equals(RoleConstants.ORGANIZATION_OWNER)) {
872
873 Group group = userGroupRole.getGroup();
874
875 Organization organization =
876 organizationPersistence.findByPrimaryKey(
877 group.getOrganizationId());
878
879 organizations.add(organization);
880 }
881 }
882
883 organizations.addAll(getUserOrganizations(userId));
884
885 return new ArrayList<Organization>(organizations);
886 }
887
888
898 @Override
899 public boolean hasPasswordPolicyOrganization(
900 long passwordPolicyId, long organizationId)
901 throws SystemException {
902
903 return passwordPolicyRelLocalService.hasPasswordPolicyRel(
904 passwordPolicyId, Organization.class.getName(), organizationId);
905 }
906
907
956 @Override
957 public boolean hasUserOrganization(
958 long userId, long organizationId, boolean inheritSuborganizations,
959 boolean includeSpecifiedOrganization)
960 throws PortalException, SystemException {
961
962 if (!inheritSuborganizations) {
963 return userPersistence.containsOrganization(userId, organizationId);
964 }
965
966 LinkedHashMap<String, Object> params =
967 new LinkedHashMap<String, Object>();
968
969 List<Organization> organizationsTree = new ArrayList<Organization>();
970
971 Organization organization = organizationPersistence.findByPrimaryKey(
972 organizationId);
973
974 if (!includeSpecifiedOrganization) {
975 organizationsTree.add(organization);
976 }
977 else {
978 organizationsTree.add(organization.getParentOrganization());
979 }
980
981 params.put("usersOrgsTree", organizationsTree);
982
983 if (userFinder.countByUser(userId, params) > 0) {
984 return true;
985 }
986
987 return false;
988 }
989
990
1004 @Override
1005 public void rebuildTree(long companyId)
1006 throws PortalException, SystemException {
1007
1008 List<Organization> organizations =
1009 organizationPersistence.findByCompanyId(companyId);
1010
1011 for (Organization organization : organizations) {
1012 organization.setTreePath(organization.buildTreePath());
1013
1014 organizationPersistence.update(organization);
1015 }
1016 }
1017
1018
1041 @Override
1042 public List<Organization> search(
1043 long companyId, LinkedHashMap<String, Object> params, int start,
1044 int end)
1045 throws SystemException {
1046
1047 return organizationFinder.findByCompanyId(
1048 companyId, params, start, end,
1049 new OrganizationNameComparator(true));
1050 }
1051
1052
1085 @Override
1086 public Hits search(
1087 long companyId, long parentOrganizationId, String keywords,
1088 LinkedHashMap<String, Object> params, int start, int end, Sort sort)
1089 throws SystemException {
1090
1091 String name = null;
1092 String type = null;
1093 String street = null;
1094 String city = null;
1095 String zip = null;
1096 String region = null;
1097 String country = null;
1098 boolean andOperator = false;
1099
1100 if (Validator.isNotNull(keywords)) {
1101 name = keywords;
1102 type = keywords;
1103 street = keywords;
1104 city = keywords;
1105 zip = keywords;
1106 region = keywords;
1107 country = keywords;
1108 }
1109 else {
1110 andOperator = true;
1111 }
1112
1113 if (params != null) {
1114 params.put("keywords", keywords);
1115 }
1116
1117 return search(
1118 companyId, parentOrganizationId, name, type, street, city, zip,
1119 region, country, params, andOperator, start, end, sort);
1120 }
1121
1122
1159 @Override
1160 public List<Organization> search(
1161 long companyId, long parentOrganizationId, String keywords,
1162 String type, Long regionId, Long countryId,
1163 LinkedHashMap<String, Object> params, int start, int end)
1164 throws SystemException {
1165
1166 return search(
1167 companyId, parentOrganizationId, keywords, type, regionId,
1168 countryId, params, start, end,
1169 new OrganizationNameComparator(true));
1170 }
1171
1172
1212 @Override
1213 public List<Organization> search(
1214 long companyId, long parentOrganizationId, String keywords,
1215 String type, Long regionId, Long countryId,
1216 LinkedHashMap<String, Object> params, int start, int end,
1217 OrderByComparator obc)
1218 throws SystemException {
1219
1220 String parentOrganizationIdComparator = StringPool.EQUAL;
1221
1222 if (parentOrganizationId ==
1223 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1224
1225 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1226 }
1227
1228 return organizationFinder.findByKeywords(
1229 companyId, parentOrganizationId, parentOrganizationIdComparator,
1230 keywords, type, regionId, countryId, params, start, end, obc);
1231 }
1232
1233
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,
1281 Long countryId, LinkedHashMap<String, Object> params,
1282 boolean andOperator, int start, int end)
1283 throws SystemException {
1284
1285 return search(
1286 companyId, parentOrganizationId, name, type, street, city, zip,
1287 regionId, countryId, params, andOperator, start, end,
1288 new OrganizationNameComparator(true));
1289 }
1290
1291
1338 @Override
1339 public List<Organization> search(
1340 long companyId, long parentOrganizationId, String name, String type,
1341 String street, String city, String zip, Long regionId,
1342 Long countryId, LinkedHashMap<String, Object> params,
1343 boolean andOperator, int start, int end, OrderByComparator obc)
1344 throws SystemException {
1345
1346 String parentOrganizationIdComparator = StringPool.EQUAL;
1347
1348 if (parentOrganizationId ==
1349 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1350
1351 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1352 }
1353
1354 return organizationFinder.findByC_PO_N_T_S_C_Z_R_C(
1355 companyId, parentOrganizationId, parentOrganizationIdComparator,
1356 name, type, street, city, zip, regionId, countryId, params,
1357 andOperator, start, end, obc);
1358 }
1359
1360
1401 @Override
1402 public Hits search(
1403 long companyId, long parentOrganizationId, String name, String type,
1404 String street, String city, String zip, String region,
1405 String country, LinkedHashMap<String, Object> params,
1406 boolean andSearch, int start, int end, Sort sort)
1407 throws SystemException {
1408
1409 try {
1410 SearchContext searchContext = new SearchContext();
1411
1412 searchContext.setAndSearch(andSearch);
1413
1414 Map<String, Serializable> attributes =
1415 new HashMap<String, Serializable>();
1416
1417 attributes.put("city", city);
1418 attributes.put("country", country);
1419 attributes.put("name", name);
1420 attributes.put("params", params);
1421 attributes.put(
1422 "parentOrganizationId", String.valueOf(parentOrganizationId));
1423 attributes.put("region", region);
1424 attributes.put("street", street);
1425 attributes.put("type", type);
1426 attributes.put("zip", zip);
1427
1428 searchContext.setAttributes(attributes);
1429
1430 searchContext.setCompanyId(companyId);
1431 searchContext.setEnd(end);
1432
1433 if (params != null) {
1434 String keywords = (String)params.remove("keywords");
1435
1436 if (Validator.isNotNull(keywords)) {
1437 searchContext.setKeywords(keywords);
1438 }
1439 }
1440
1441 QueryConfig queryConfig = new QueryConfig();
1442
1443 queryConfig.setHighlightEnabled(false);
1444 queryConfig.setScoreEnabled(false);
1445
1446 searchContext.setQueryConfig(queryConfig);
1447
1448 if (sort != null) {
1449 searchContext.setSorts(sort);
1450 }
1451
1452 searchContext.setStart(start);
1453
1454 Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1455 Organization.class);
1456
1457 return indexer.search(searchContext);
1458 }
1459 catch (Exception e) {
1460 throw new SystemException(e);
1461 }
1462 }
1463
1464
1486 @Override
1487 public int searchCount(
1488 long companyId, long parentOrganizationId, String keywords,
1489 String type, Long regionId, Long countryId,
1490 LinkedHashMap<String, Object> params)
1491 throws SystemException {
1492
1493 String parentOrganizationIdComparator = StringPool.EQUAL;
1494
1495 if (parentOrganizationId ==
1496 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1497
1498 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1499 }
1500
1501 return organizationFinder.countByKeywords(
1502 companyId, parentOrganizationId, parentOrganizationIdComparator,
1503 keywords, type, regionId, countryId, params);
1504 }
1505
1506
1535 @Override
1536 public int searchCount(
1537 long companyId, long parentOrganizationId, String name, String type,
1538 String street, String city, String zip, Long regionId,
1539 Long countryId, LinkedHashMap<String, Object> params,
1540 boolean andOperator)
1541 throws SystemException {
1542
1543 String parentOrganizationIdComparator = StringPool.EQUAL;
1544
1545 if (parentOrganizationId ==
1546 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1547
1548 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1549 }
1550
1551 return organizationFinder.countByC_PO_N_T_S_C_Z_R_C(
1552 companyId, parentOrganizationId, parentOrganizationIdComparator,
1553 name, type, street, city, zip, regionId, countryId, params,
1554 andOperator);
1555 }
1556
1557
1566 @Override
1567 public void setGroupOrganizations(long groupId, long[] organizationIds)
1568 throws PortalException, SystemException {
1569
1570 groupPersistence.setOrganizations(groupId, organizationIds);
1571
1572 PermissionCacheUtil.clearCache();
1573 }
1574
1575
1583 @Override
1584 public void unsetGroupOrganizations(long groupId, long[] organizationIds)
1585 throws PortalException, SystemException {
1586
1587 groupPersistence.removeOrganizations(groupId, organizationIds);
1588
1589 PermissionCacheUtil.clearCache();
1590 }
1591
1592
1599 @Override
1600 public void unsetPasswordPolicyOrganizations(
1601 long passwordPolicyId, long[] organizationIds)
1602 throws SystemException {
1603
1604 passwordPolicyRelLocalService.deletePasswordPolicyRels(
1605 passwordPolicyId, Organization.class.getName(), organizationIds);
1606 }
1607
1608
1619 @Override
1620 public void updateAsset(
1621 long userId, Organization organization, long[] assetCategoryIds,
1622 String[] assetTagNames)
1623 throws PortalException, SystemException {
1624
1625 User user = userPersistence.findByPrimaryKey(userId);
1626
1627 Company company = companyPersistence.findByPrimaryKey(
1628 user.getCompanyId());
1629
1630 Group companyGroup = company.getGroup();
1631
1632 assetEntryLocalService.updateEntry(
1633 userId, companyGroup.getGroupId(), null, null,
1634 Organization.class.getName(), organization.getOrganizationId(),
1635 organization.getUuid(), 0, assetCategoryIds, assetTagNames, false,
1636 null, null, null, null, organization.getName(), StringPool.BLANK,
1637 null, null, null, 0, 0, null, false);
1638 }
1639
1640
1670 @Override
1671 public Organization updateOrganization(
1672 long companyId, long organizationId, long parentOrganizationId,
1673 String name, String type, boolean recursable, long regionId,
1674 long countryId, int statusId, String comments, boolean site,
1675 ServiceContext serviceContext)
1676 throws PortalException, SystemException {
1677
1678 return updateOrganization(
1679 companyId, organizationId, parentOrganizationId, name, type,
1680 regionId, countryId, statusId, comments, site, serviceContext);
1681 }
1682
1683
1708 @Override
1709 public Organization updateOrganization(
1710 long companyId, long organizationId, long parentOrganizationId,
1711 String name, String type, long regionId, long countryId,
1712 int statusId, String comments, boolean site,
1713 ServiceContext serviceContext)
1714 throws PortalException, SystemException {
1715
1716
1717
1718 parentOrganizationId = getParentOrganizationId(
1719 companyId, parentOrganizationId);
1720
1721 validate(
1722 companyId, organizationId, parentOrganizationId, name, type,
1723 countryId, statusId);
1724
1725 Organization organization = organizationPersistence.findByPrimaryKey(
1726 organizationId);
1727
1728 long oldParentOrganizationId = organization.getParentOrganizationId();
1729 String oldName = organization.getName();
1730
1731 organization.setModifiedDate(new Date());
1732 organization.setParentOrganizationId(parentOrganizationId);
1733 organization.setTreePath(organization.buildTreePath());
1734 organization.setName(name);
1735 organization.setType(type);
1736 organization.setRecursable(true);
1737 organization.setRegionId(regionId);
1738 organization.setCountryId(countryId);
1739 organization.setStatusId(statusId);
1740 organization.setComments(comments);
1741 organization.setExpandoBridgeAttributes(serviceContext);
1742
1743 organizationPersistence.update(organization);
1744
1745
1746
1747 Group group = organization.getGroup();
1748
1749 long parentGroupId = group.getParentGroupId();
1750
1751 boolean organizationGroup = isOrganizationGroup(
1752 oldParentOrganizationId, group.getParentGroupId());
1753
1754 if (organizationGroup) {
1755 if (parentOrganizationId !=
1756 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1757
1758 Organization parentOrganization =
1759 organizationPersistence.fetchByPrimaryKey(
1760 parentOrganizationId);
1761
1762 Group parentGroup = parentOrganization.getGroup();
1763
1764 if (site && parentGroup.isSite()) {
1765 parentGroupId = parentOrganization.getGroupId();
1766 }
1767 else {
1768 parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
1769 }
1770 }
1771 else {
1772 parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
1773 }
1774 }
1775
1776 if (!oldName.equals(name) || organizationGroup) {
1777 groupLocalService.updateGroup(
1778 group.getGroupId(), parentGroupId, name, group.getDescription(),
1779 group.getType(), group.isManualMembership(),
1780 group.getMembershipRestriction(), group.getFriendlyURL(),
1781 group.isActive(), null);
1782 }
1783
1784 if (group.isSite() != site) {
1785 groupLocalService.updateSite(group.getGroupId(), site);
1786 }
1787
1788
1789
1790 if (serviceContext != null) {
1791 updateAsset(
1792 serviceContext.getUserId(), organization,
1793 serviceContext.getAssetCategoryIds(),
1794 serviceContext.getAssetTagNames());
1795 }
1796
1797
1798
1799 Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1800 Organization.class);
1801
1802 if (oldParentOrganizationId != parentOrganizationId) {
1803 long[] organizationIds = getReindexOrganizationIds(organization);
1804
1805 indexer.reindex(organizationIds);
1806 }
1807 else {
1808 indexer.reindex(organization);
1809 }
1810
1811 return organization;
1812 }
1813
1814 protected void addSuborganizations(
1815 List<Organization> allSuborganizations,
1816 List<Organization> organizations)
1817 throws SystemException {
1818
1819 for (Organization organization : organizations) {
1820 if (!allSuborganizations.contains(organization)) {
1821 allSuborganizations.add(organization);
1822
1823 List<Organization> suborganizations =
1824 organizationPersistence.findByC_P(
1825 organization.getCompanyId(),
1826 organization.getOrganizationId());
1827
1828 addSuborganizations(allSuborganizations, suborganizations);
1829 }
1830 }
1831 }
1832
1833 protected long getParentOrganizationId(
1834 long companyId, long parentOrganizationId)
1835 throws SystemException {
1836
1837 if (parentOrganizationId !=
1838 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1839
1840
1841
1842
1843 Organization parentOrganization =
1844 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
1845
1846 if ((parentOrganization == null) ||
1847 (companyId != parentOrganization.getCompanyId())) {
1848
1849 parentOrganizationId =
1850 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID;
1851 }
1852 }
1853
1854 return parentOrganizationId;
1855 }
1856
1857 protected long[] getReindexOrganizationIds(Organization organization)
1858 throws PortalException, SystemException {
1859
1860 List<Organization> organizationsTree = new ArrayList<Organization>();
1861
1862 organizationsTree.add(organization);
1863
1864 LinkedHashMap<String, Object> params =
1865 new LinkedHashMap<String, Object>();
1866
1867 params.put("organizationsTree", organizationsTree);
1868
1869 List<Organization> organizations = search(
1870 organization.getCompanyId(), params, QueryUtil.ALL_POS,
1871 QueryUtil.ALL_POS);
1872
1873 long[] organizationIds = new long[organizations.size()];
1874
1875 for (int i = 0; i < organizations.size(); i++) {
1876 Organization curOrganization = organizations.get(i);
1877
1878 curOrganization.setTreePath(curOrganization.buildTreePath());
1879
1880 organizationPersistence.update(curOrganization);
1881
1882 organizationIds[i] = curOrganization.getOrganizationId();
1883 }
1884
1885 if (!ArrayUtil.contains(
1886 organizationIds, organization.getOrganizationId())) {
1887
1888 organizationIds = ArrayUtil.append(
1889 organizationIds, organization.getOrganizationId());
1890 }
1891
1892 return organizationIds;
1893 }
1894
1895 protected boolean isOrganizationGroup(long organizationId, long groupId)
1896 throws SystemException {
1897
1898 if ((organizationId ==
1899 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) &&
1900 (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
1901
1902 return true;
1903 }
1904
1905 if (organizationId !=
1906 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1907
1908 Organization organization =
1909 organizationPersistence.fetchByPrimaryKey(organizationId);
1910
1911 if (organization.getGroupId() == groupId) {
1912 return true;
1913 }
1914 }
1915
1916 return false;
1917 }
1918
1919 protected boolean isParentOrganization(
1920 long parentOrganizationId, long organizationId)
1921 throws PortalException, SystemException {
1922
1923
1924
1925
1926 if (organizationId ==
1927 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1928
1929 return false;
1930 }
1931
1932 Organization organization = organizationPersistence.findByPrimaryKey(
1933 organizationId);
1934
1935 String treePath = organization.getTreePath();
1936
1937 if (treePath.contains(
1938 StringPool.SLASH + parentOrganizationId + StringPool.SLASH)) {
1939
1940 return true;
1941 }
1942 else {
1943 return false;
1944 }
1945 }
1946
1947 protected void validate(
1948 long companyId, long organizationId, long parentOrganizationId,
1949 String name, String type, long countryId, int statusId)
1950 throws PortalException, SystemException {
1951
1952 if (!ArrayUtil.contains(PropsValues.ORGANIZATIONS_TYPES, type)) {
1953 throw new OrganizationTypeException(
1954 "Invalid organization type " + type);
1955 }
1956
1957 if (parentOrganizationId ==
1958 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1959
1960 if (!OrganizationImpl.isRootable(type)) {
1961 throw new OrganizationParentException(
1962 "Organization of type " + type + " cannot be a root");
1963 }
1964 }
1965 else {
1966 Organization parentOrganization =
1967 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
1968
1969 if (parentOrganization == null) {
1970 throw new OrganizationParentException(
1971 "Organization " + parentOrganizationId + " doesn't exist");
1972 }
1973
1974 String[] childrenTypes = OrganizationImpl.getChildrenTypes(
1975 parentOrganization.getType());
1976
1977 if (childrenTypes.length == 0) {
1978 throw new OrganizationParentException(
1979 "Organization of type " + type + " cannot have children");
1980 }
1981
1982 if ((companyId != parentOrganization.getCompanyId()) ||
1983 (parentOrganizationId == organizationId)) {
1984
1985 throw new OrganizationParentException();
1986 }
1987
1988 if (!ArrayUtil.contains(childrenTypes, type)) {
1989 throw new OrganizationParentException(
1990 "Type " + type + " not allowed as child of " +
1991 parentOrganization.getType());
1992 }
1993 }
1994
1995 if ((organizationId > 0) &&
1996 (parentOrganizationId !=
1997 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID)) {
1998
1999
2000
2001 if (isParentOrganization(organizationId, parentOrganizationId)) {
2002 throw new OrganizationParentException();
2003 }
2004 }
2005
2006 if (Validator.isNull(name)) {
2007 throw new OrganizationNameException();
2008 }
2009 else {
2010 Organization organization = organizationPersistence.fetchByC_N(
2011 companyId, name);
2012
2013 if ((organization != null) &&
2014 StringUtil.equalsIgnoreCase(organization.getName(), name)) {
2015
2016 if ((organizationId <= 0) ||
2017 (organization.getOrganizationId() != organizationId)) {
2018
2019 throw new DuplicateOrganizationException(
2020 "There is another organization named " + name);
2021 }
2022 }
2023 }
2024
2025 boolean countryRequired = GetterUtil.getBoolean(
2026 PropsUtil.get(
2027 PropsKeys.ORGANIZATIONS_COUNTRY_REQUIRED, new Filter(type)));
2028
2029 if (countryRequired || (countryId > 0)) {
2030 countryPersistence.findByPrimaryKey(countryId);
2031 }
2032
2033 listTypeService.validate(
2034 statusId, ListTypeConstants.ORGANIZATION_STATUS);
2035 }
2036
2037 protected void validate(
2038 long companyId, long parentOrganizationId, String name, String type,
2039 long countryId, int statusId)
2040 throws PortalException, SystemException {
2041
2042 validate(
2043 companyId, 0, parentOrganizationId, name, type, countryId,
2044 statusId);
2045 }
2046
2047 }