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.TreeModel;
054 import com.liferay.portal.model.User;
055 import com.liferay.portal.model.UserGroupRole;
056 import com.liferay.portal.model.impl.OrganizationImpl;
057 import com.liferay.portal.security.permission.PermissionCacheUtil;
058 import com.liferay.portal.service.ServiceContext;
059 import com.liferay.portal.service.base.OrganizationLocalServiceBaseImpl;
060 import com.liferay.portal.util.PropsUtil;
061 import com.liferay.portal.util.PropsValues;
062 import com.liferay.portal.util.comparator.OrganizationIdComparator;
063 import com.liferay.portal.util.comparator.OrganizationNameComparator;
064 import com.liferay.util.dao.orm.CustomSQLUtil;
065
066 import java.io.Serializable;
067
068 import java.util.ArrayList;
069 import java.util.Collections;
070 import java.util.Date;
071 import java.util.HashMap;
072 import java.util.HashSet;
073 import java.util.Iterator;
074 import java.util.LinkedHashMap;
075 import java.util.List;
076 import java.util.Map;
077 import java.util.Set;
078
079
089 public class OrganizationLocalServiceImpl
090 extends OrganizationLocalServiceBaseImpl {
091
092
101 @Override
102 public void addGroupOrganizations(long groupId, long[] organizationIds)
103 throws PortalException, SystemException {
104
105 groupPersistence.addOrganizations(groupId, organizationIds);
106
107 PermissionCacheUtil.clearCache();
108 }
109
110
132 @Override
133 public Organization addOrganization(
134 long userId, long parentOrganizationId, String name, boolean site)
135 throws PortalException, SystemException {
136
137 return addOrganization(
138 userId, parentOrganizationId, name,
139 OrganizationConstants.TYPE_REGULAR_ORGANIZATION, 0, 0,
140 ListTypeConstants.ORGANIZATION_STATUS_DEFAULT, StringPool.BLANK,
141 site, null);
142 }
143
144
180 @Override
181 public Organization addOrganization(
182 long userId, long parentOrganizationId, String name, String type,
183 boolean recursable, long regionId, long countryId, int statusId,
184 String comments, boolean site, ServiceContext serviceContext)
185 throws PortalException, SystemException {
186
187 return addOrganization(
188 userId, parentOrganizationId, name, type, regionId, countryId,
189 statusId, comments, site, serviceContext);
190 }
191
192
222 @Override
223 public Organization addOrganization(
224 long userId, long parentOrganizationId, String name, String type,
225 long regionId, long countryId, int statusId, String comments,
226 boolean site, ServiceContext serviceContext)
227 throws PortalException, SystemException {
228
229
230
231 User user = userPersistence.findByPrimaryKey(userId);
232 parentOrganizationId = getParentOrganizationId(
233 user.getCompanyId(), parentOrganizationId);
234 Date now = new Date();
235
236 validate(
237 user.getCompanyId(), parentOrganizationId, name, type, countryId,
238 statusId);
239
240 long organizationId = counterLocalService.increment();
241
242 Organization organization = organizationPersistence.create(
243 organizationId);
244
245 if (serviceContext != null) {
246 organization.setUuid(serviceContext.getUuid());
247 }
248
249 organization.setCompanyId(user.getCompanyId());
250 organization.setUserId(user.getUserId());
251 organization.setUserName(user.getFullName());
252
253 if (serviceContext != null) {
254 organization.setCreateDate(serviceContext.getCreateDate(now));
255 organization.setModifiedDate(serviceContext.getModifiedDate(now));
256 }
257 else {
258 organization.setCreateDate(now);
259 organization.setModifiedDate(now);
260 }
261
262 organization.setParentOrganizationId(parentOrganizationId);
263 organization.setTreePath(organization.buildTreePath());
264 organization.setName(name);
265 organization.setType(type);
266 organization.setRecursable(true);
267 organization.setRegionId(regionId);
268 organization.setCountryId(countryId);
269 organization.setStatusId(statusId);
270 organization.setComments(comments);
271 organization.setExpandoBridgeAttributes(serviceContext);
272
273 organizationPersistence.update(organization);
274
275
276
277 long parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
278
279 if (parentOrganizationId !=
280 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
281
282 Organization parentOrganization =
283 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
284
285 if (parentOrganization != null) {
286 Group parentGroup = parentOrganization.getGroup();
287
288 if (site && parentGroup.isSite()) {
289 parentGroupId = parentOrganization.getGroupId();
290 }
291 }
292 }
293
294 Group group = groupLocalService.addGroup(
295 userId, parentGroupId, Organization.class.getName(), organizationId,
296 GroupConstants.DEFAULT_LIVE_GROUP_ID, name, null,
297 GroupConstants.TYPE_SITE_PRIVATE, false,
298 GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, null, site, true,
299 null);
300
301
302
303 Role role = roleLocalService.getRole(
304 organization.getCompanyId(), RoleConstants.ORGANIZATION_OWNER);
305
306 userGroupRoleLocalService.addUserGroupRoles(
307 userId, group.getGroupId(), new long[] {role.getRoleId()});
308
309
310
311 addOrganizationResources(userId, organization);
312
313
314
315 if (serviceContext != null) {
316 updateAsset(
317 userId, organization, serviceContext.getAssetCategoryIds(),
318 serviceContext.getAssetTagNames());
319 }
320
321
322
323 if ((serviceContext == null) || serviceContext.isIndexingEnabled()) {
324 Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
325 Organization.class);
326
327 indexer.reindex(organization);
328 }
329
330 return organization;
331 }
332
333
342 @Override
343 public void addOrganizationResources(long userId, Organization organization)
344 throws PortalException, SystemException {
345
346 String name = Organization.class.getName();
347
348 resourceLocalService.addResources(
349 organization.getCompanyId(), 0, userId, name,
350 organization.getOrganizationId(), false, false, false);
351 }
352
353
361 @Override
362 public void addPasswordPolicyOrganizations(
363 long passwordPolicyId, long[] organizationIds)
364 throws SystemException {
365
366 passwordPolicyRelLocalService.addPasswordPolicyRels(
367 passwordPolicyId, Organization.class.getName(), organizationIds);
368 }
369
370
379 @Override
380 public void deleteLogo(long organizationId)
381 throws PortalException, SystemException {
382
383 Organization organization = getOrganization(organizationId);
384
385 Group group = organization.getGroup();
386
387 LayoutSet publicLayoutSet = layoutSetLocalService.getLayoutSet(
388 group.getGroupId(), false);
389
390 if (publicLayoutSet.isLogo()) {
391 long logoId = publicLayoutSet.getLogoId();
392
393 publicLayoutSet.setLogo(false);
394 publicLayoutSet.setLogoId(0);
395
396 layoutSetPersistence.update(publicLayoutSet);
397
398 imageLocalService.deleteImage(logoId);
399 }
400
401 LayoutSet privateLayoutSet = layoutSetLocalService.getLayoutSet(
402 group.getGroupId(), true);
403
404 if (privateLayoutSet.isLogo()) {
405 long logoId = privateLayoutSet.getLogoId();
406
407 privateLayoutSet.setLogo(false);
408 privateLayoutSet.setLogoId(0);
409
410 layoutSetPersistence.update(privateLayoutSet);
411
412 if (imageLocalService.getImage(logoId) != null) {
413 imageLocalService.deleteImage(logoId);
414 }
415 }
416 }
417
418
429 @Override
430 public Organization deleteOrganization(long organizationId)
431 throws PortalException, SystemException {
432
433 Organization organization = organizationPersistence.findByPrimaryKey(
434 organizationId);
435
436 return deleteOrganization(organization);
437 }
438
439
449 @Override
450 public Organization deleteOrganization(Organization organization)
451 throws PortalException, SystemException {
452
453 if ((userLocalService.getOrganizationUsersCount(
454 organization.getOrganizationId(),
455 WorkflowConstants.STATUS_APPROVED) > 0) ||
456 (organizationPersistence.countByC_P(
457 organization.getCompanyId(),
458 organization.getOrganizationId()) > 0)) {
459
460 throw new RequiredOrganizationException();
461 }
462
463
464
465 assetEntryLocalService.deleteEntry(
466 Organization.class.getName(), organization.getOrganizationId());
467
468
469
470 addressLocalService.deleteAddresses(
471 organization.getCompanyId(), Organization.class.getName(),
472 organization.getOrganizationId());
473
474
475
476 emailAddressLocalService.deleteEmailAddresses(
477 organization.getCompanyId(), Organization.class.getName(),
478 organization.getOrganizationId());
479
480
481
482 expandoRowLocalService.deleteRows(organization.getOrganizationId());
483
484
485
486 passwordPolicyRelLocalService.deletePasswordPolicyRel(
487 Organization.class.getName(), organization.getOrganizationId());
488
489
490
491 phoneLocalService.deletePhones(
492 organization.getCompanyId(), Organization.class.getName(),
493 organization.getOrganizationId());
494
495
496
497 websiteLocalService.deleteWebsites(
498 organization.getCompanyId(), Organization.class.getName(),
499 organization.getOrganizationId());
500
501
502
503 Group group = organization.getGroup();
504
505 if (group.isSite()) {
506 group.setSite(false);
507
508 groupPersistence.update(group);
509 }
510
511 groupLocalService.deleteGroup(group);
512
513
514
515 String name = Organization.class.getName();
516
517 resourceLocalService.deleteResource(
518 organization.getCompanyId(), name,
519 ResourceConstants.SCOPE_INDIVIDUAL,
520 organization.getOrganizationId());
521
522
523
524 organizationPersistence.remove(organization);
525
526
527
528 PermissionCacheUtil.clearCache();
529
530 return organization;
531 }
532
533 @Override
534 public Organization fetchOrganization(long companyId, String name)
535 throws SystemException {
536
537 return organizationPersistence.fetchByC_N(companyId, name);
538 }
539
540 @Override
541 public List<Organization> getNoAssetOrganizations() throws SystemException {
542 return organizationFinder.findByNoAssets();
543 }
544
545
555 @Override
556 public Organization getOrganization(long companyId, String name)
557 throws PortalException, SystemException {
558
559 return organizationPersistence.findByC_N(companyId, name);
560 }
561
562
571 @Override
572 public long getOrganizationId(long companyId, String name)
573 throws SystemException {
574
575 Organization organization = organizationPersistence.fetchByC_N(
576 companyId, name);
577
578 if (organization != null) {
579 return organization.getOrganizationId();
580 }
581 else {
582 return 0;
583 }
584 }
585
586 @Override
587 public List<Organization> getOrganizations(
588 long userId, int start, int end, OrderByComparator obc)
589 throws PortalException, SystemException {
590
591 User user = userPersistence.findByPrimaryKey(userId);
592
593 List<Organization> organizations = ListUtil.copy(
594 userPersistence.getOrganizations(userId));
595
596 Iterator<Organization> iterator = organizations.iterator();
597
598 while (iterator.hasNext()) {
599 Organization organization = iterator.next();
600
601 if (organization.getCompanyId() != user.getCompanyId()) {
602 iterator.remove();
603 }
604 }
605
606 if (organizations.isEmpty()) {
607 return organizations;
608 }
609
610 if (obc == null) {
611 obc = new OrganizationNameComparator(true);
612 }
613
614 Collections.sort(organizations, obc);
615
616 return ListUtil.subList(organizations, start, end);
617 }
618
619
628 @Override
629 public List<Organization> getOrganizations(
630 long companyId, long parentOrganizationId)
631 throws SystemException {
632
633 return getOrganizations(
634 companyId, parentOrganizationId, QueryUtil.ALL_POS,
635 QueryUtil.ALL_POS);
636 }
637
638
663 @Override
664 public List<Organization> getOrganizations(
665 long companyId, long parentOrganizationId, int start, int end)
666 throws SystemException {
667
668 if (parentOrganizationId ==
669 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
670
671 return organizationPersistence.findByCompanyId(
672 companyId, start, end);
673 }
674 else {
675 return organizationPersistence.findByC_P(
676 companyId, parentOrganizationId, start, end);
677 }
678 }
679
680
689 @Override
690 public List<Organization> getOrganizations(long[] organizationIds)
691 throws PortalException, SystemException {
692
693 List<Organization> organizations = new ArrayList<Organization>(
694 organizationIds.length);
695
696 for (long organizationId : organizationIds) {
697 Organization organization = getOrganization(organizationId);
698
699 organizations.add(organization);
700 }
701
702 return organizations;
703 }
704
705
714 @Override
715 public int getOrganizationsCount(long companyId, long parentOrganizationId)
716 throws SystemException {
717
718 if (parentOrganizationId ==
719 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
720
721 return organizationPersistence.countByCompanyId(companyId);
722 }
723 else {
724 return organizationPersistence.countByC_P(
725 companyId, parentOrganizationId);
726 }
727 }
728
729
739 @Override
740 public List<Organization> getParentOrganizations(long organizationId)
741 throws PortalException, SystemException {
742
743 if (organizationId ==
744 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
745
746 return new ArrayList<Organization>();
747 }
748
749 Organization organization = organizationPersistence.findByPrimaryKey(
750 organizationId);
751
752 return organization.getAncestors();
753 }
754
755
763 @Override
764 public List<Organization> getSuborganizations(
765 List<Organization> organizations)
766 throws SystemException {
767
768 List<Organization> allSuborganizations = new ArrayList<Organization>();
769
770 for (int i = 0; i < organizations.size(); i++) {
771 Organization organization = organizations.get(i);
772
773 List<Organization> suborganizations =
774 organizationPersistence.findByC_P(
775 organization.getCompanyId(),
776 organization.getOrganizationId());
777
778 addSuborganizations(allSuborganizations, suborganizations);
779 }
780
781 return allSuborganizations;
782 }
783
784
792 @Override
793 public List<Organization> getSuborganizations(
794 long companyId, long organizationId)
795 throws SystemException {
796
797 return organizationPersistence.findByC_P(companyId, organizationId);
798 }
799
800
808 @Override
809 public int getSuborganizationsCount(long companyId, long organizationId)
810 throws SystemException {
811
812 return organizationPersistence.countByC_P(companyId, organizationId);
813 }
814
815
824 @Override
825 public List<Organization> getSubsetOrganizations(
826 List<Organization> allOrganizations,
827 List<Organization> availableOrganizations) {
828
829 List<Organization> subsetOrganizations = new ArrayList<Organization>();
830
831 for (Organization organization : allOrganizations) {
832 if (availableOrganizations.contains(organization)) {
833 subsetOrganizations.add(organization);
834 }
835 }
836
837 return subsetOrganizations;
838 }
839
840
854 @Override
855 public List<Organization> getUserOrganizations(
856 long userId, boolean includeAdministrative)
857 throws PortalException, SystemException {
858
859 if (!includeAdministrative) {
860 return getUserOrganizations(userId);
861 }
862
863 Set<Organization> organizations = new HashSet<Organization>();
864
865 List<UserGroupRole> userGroupRoles =
866 userGroupRoleLocalService.getUserGroupRoles(userId);
867
868 for (UserGroupRole userGroupRole : userGroupRoles) {
869 Role role = userGroupRole.getRole();
870
871 String roleName = role.getName();
872
873 if (roleName.equals(RoleConstants.ORGANIZATION_ADMINISTRATOR) ||
874 roleName.equals(RoleConstants.ORGANIZATION_OWNER)) {
875
876 Group group = userGroupRole.getGroup();
877
878 Organization organization =
879 organizationPersistence.findByPrimaryKey(
880 group.getOrganizationId());
881
882 organizations.add(organization);
883 }
884 }
885
886 organizations.addAll(getUserOrganizations(userId));
887
888 return new ArrayList<Organization>(organizations);
889 }
890
891
901 @Override
902 public boolean hasPasswordPolicyOrganization(
903 long passwordPolicyId, long organizationId)
904 throws SystemException {
905
906 return passwordPolicyRelLocalService.hasPasswordPolicyRel(
907 passwordPolicyId, Organization.class.getName(), organizationId);
908 }
909
910
959 @Override
960 public boolean hasUserOrganization(
961 long userId, long organizationId, boolean inheritSuborganizations,
962 boolean includeSpecifiedOrganization)
963 throws PortalException, SystemException {
964
965 if (!inheritSuborganizations) {
966 return userPersistence.containsOrganization(userId, organizationId);
967 }
968
969 LinkedHashMap<String, Object> params =
970 new LinkedHashMap<String, Object>();
971
972 List<Organization> organizationsTree = new ArrayList<Organization>();
973
974 Organization organization = organizationPersistence.findByPrimaryKey(
975 organizationId);
976
977 if (!includeSpecifiedOrganization) {
978 organizationsTree.add(organization);
979 }
980 else {
981 organizationsTree.add(organization.getParentOrganization());
982 }
983
984 params.put("usersOrgsTree", organizationsTree);
985
986 if (userFinder.countByUser(userId, params) > 0) {
987 return true;
988 }
989
990 return false;
991 }
992
993
1007 @Override
1008 public void rebuildTree(long companyId)
1009 throws PortalException, SystemException {
1010
1011 TreePathUtil.rebuildTree(
1012 companyId, OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID,
1013 StringPool.SLASH,
1014 new TreeModelFinder<Organization>() {
1015
1016 @Override
1017 public List<Organization> findTreeModels(
1018 long previousId, long companyId, long parentPrimaryKey,
1019 int size)
1020 throws SystemException {
1021
1022 return organizationPersistence.findByO_C_P(
1023 previousId, companyId, parentPrimaryKey,
1024 QueryUtil.ALL_POS, size,
1025 new OrganizationIdComparator());
1026 }
1027
1028 @Override
1029 public void rebuildDependentModelsTreePaths(
1030 long parentPrimaryKey, String treePath) {
1031 }
1032
1033 @Override
1034 public void reindexTreeModels(List<TreeModel> treeModels) {
1035 }
1036
1037 }
1038 );
1039 }
1040
1041
1074 @Override
1075 public Hits search(
1076 long companyId, long parentOrganizationId, String keywords,
1077 LinkedHashMap<String, Object> params, int start, int end, Sort sort)
1078 throws SystemException {
1079
1080 String name = null;
1081 String type = null;
1082 String street = null;
1083 String city = null;
1084 String zip = null;
1085 String region = null;
1086 String country = null;
1087 boolean andOperator = false;
1088
1089 if (Validator.isNotNull(keywords)) {
1090 name = keywords;
1091 type = keywords;
1092 street = keywords;
1093 city = keywords;
1094 zip = keywords;
1095 region = keywords;
1096 country = keywords;
1097 }
1098 else {
1099 andOperator = true;
1100 }
1101
1102 if (params != null) {
1103 params.put("keywords", keywords);
1104 }
1105
1106 return search(
1107 companyId, parentOrganizationId, name, type, street, city, zip,
1108 region, country, params, andOperator, start, end, sort);
1109 }
1110
1111
1148 @Override
1149 public List<Organization> search(
1150 long companyId, long parentOrganizationId, String keywords,
1151 String type, Long regionId, Long countryId,
1152 LinkedHashMap<String, Object> params, int start, int end)
1153 throws SystemException {
1154
1155 return search(
1156 companyId, parentOrganizationId, keywords, type, regionId,
1157 countryId, params, start, end,
1158 new OrganizationNameComparator(true));
1159 }
1160
1161
1201 @Override
1202 public List<Organization> search(
1203 long companyId, long parentOrganizationId, String keywords,
1204 String type, Long regionId, Long countryId,
1205 LinkedHashMap<String, Object> params, int start, int end,
1206 OrderByComparator obc)
1207 throws SystemException {
1208
1209 String parentOrganizationIdComparator = StringPool.EQUAL;
1210
1211 if (parentOrganizationId ==
1212 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1213
1214 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1215 }
1216
1217 return organizationFinder.findByKeywords(
1218 companyId, parentOrganizationId, parentOrganizationIdComparator,
1219 keywords, type, regionId, countryId, params, start, end, obc);
1220 }
1221
1222
1266 @Override
1267 public List<Organization> search(
1268 long companyId, long parentOrganizationId, String name, String type,
1269 String street, String city, String zip, Long regionId,
1270 Long countryId, LinkedHashMap<String, Object> params,
1271 boolean andOperator, int start, int end)
1272 throws SystemException {
1273
1274 return search(
1275 companyId, parentOrganizationId, name, type, street, city, zip,
1276 regionId, countryId, params, andOperator, start, end,
1277 new OrganizationNameComparator(true));
1278 }
1279
1280
1327 @Override
1328 public List<Organization> search(
1329 long companyId, long parentOrganizationId, String name, String type,
1330 String street, String city, String zip, Long regionId,
1331 Long countryId, LinkedHashMap<String, Object> params,
1332 boolean andOperator, int start, int end, OrderByComparator obc)
1333 throws SystemException {
1334
1335 String parentOrganizationIdComparator = StringPool.EQUAL;
1336
1337 if (parentOrganizationId ==
1338 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1339
1340 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1341 }
1342
1343 return organizationFinder.findByC_PO_N_T_S_C_Z_R_C(
1344 companyId, parentOrganizationId, parentOrganizationIdComparator,
1345 name, type, street, city, zip, regionId, countryId, params,
1346 andOperator, start, end, obc);
1347 }
1348
1349
1390 @Override
1391 public Hits search(
1392 long companyId, long parentOrganizationId, String name, String type,
1393 String street, String city, String zip, String region,
1394 String country, LinkedHashMap<String, Object> params,
1395 boolean andSearch, int start, int end, Sort sort)
1396 throws SystemException {
1397
1398 try {
1399 SearchContext searchContext = new SearchContext();
1400
1401 searchContext.setAndSearch(andSearch);
1402
1403 Map<String, Serializable> attributes =
1404 new HashMap<String, Serializable>();
1405
1406 attributes.put("city", city);
1407 attributes.put("country", country);
1408 attributes.put("name", name);
1409 attributes.put("params", params);
1410 attributes.put(
1411 "parentOrganizationId", String.valueOf(parentOrganizationId));
1412 attributes.put("region", region);
1413 attributes.put("street", street);
1414 attributes.put("type", type);
1415 attributes.put("zip", zip);
1416
1417 searchContext.setAttributes(attributes);
1418
1419 searchContext.setCompanyId(companyId);
1420 searchContext.setEnd(end);
1421
1422 if (params != null) {
1423 String keywords = (String)params.remove("keywords");
1424
1425 if (Validator.isNotNull(keywords)) {
1426 searchContext.setKeywords(keywords);
1427 }
1428 }
1429
1430 QueryConfig queryConfig = new QueryConfig();
1431
1432 queryConfig.setHighlightEnabled(false);
1433 queryConfig.setScoreEnabled(false);
1434
1435 searchContext.setQueryConfig(queryConfig);
1436
1437 if (sort != null) {
1438 searchContext.setSorts(sort);
1439 }
1440
1441 searchContext.setStart(start);
1442
1443 Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1444 Organization.class);
1445
1446 return indexer.search(searchContext);
1447 }
1448 catch (Exception e) {
1449 throw new SystemException(e);
1450 }
1451 }
1452
1453
1475 @Override
1476 public int searchCount(
1477 long companyId, long parentOrganizationId, String keywords,
1478 String type, Long regionId, Long countryId,
1479 LinkedHashMap<String, Object> params)
1480 throws SystemException {
1481
1482 String parentOrganizationIdComparator = StringPool.EQUAL;
1483
1484 if (parentOrganizationId ==
1485 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1486
1487 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1488 }
1489
1490 return organizationFinder.countByKeywords(
1491 companyId, parentOrganizationId, parentOrganizationIdComparator,
1492 keywords, type, regionId, countryId, params);
1493 }
1494
1495
1524 @Override
1525 public int searchCount(
1526 long companyId, long parentOrganizationId, String name, String type,
1527 String street, String city, String zip, Long regionId,
1528 Long countryId, LinkedHashMap<String, Object> params,
1529 boolean andOperator)
1530 throws SystemException {
1531
1532 String parentOrganizationIdComparator = StringPool.EQUAL;
1533
1534 if (parentOrganizationId ==
1535 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
1536
1537 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
1538 }
1539
1540 return organizationFinder.countByC_PO_N_T_S_C_Z_R_C(
1541 companyId, parentOrganizationId, parentOrganizationIdComparator,
1542 name, type, street, city, zip, regionId, countryId, params,
1543 andOperator);
1544 }
1545
1546
1555 @Override
1556 public void setGroupOrganizations(long groupId, long[] organizationIds)
1557 throws PortalException, SystemException {
1558
1559 groupPersistence.setOrganizations(groupId, organizationIds);
1560
1561 PermissionCacheUtil.clearCache();
1562 }
1563
1564
1572 @Override
1573 public void unsetGroupOrganizations(long groupId, long[] organizationIds)
1574 throws PortalException, SystemException {
1575
1576 groupPersistence.removeOrganizations(groupId, organizationIds);
1577
1578 PermissionCacheUtil.clearCache();
1579 }
1580
1581
1588 @Override
1589 public void unsetPasswordPolicyOrganizations(
1590 long passwordPolicyId, long[] organizationIds)
1591 throws SystemException {
1592
1593 passwordPolicyRelLocalService.deletePasswordPolicyRels(
1594 passwordPolicyId, Organization.class.getName(), organizationIds);
1595 }
1596
1597
1608 @Override
1609 public void updateAsset(
1610 long userId, Organization organization, long[] assetCategoryIds,
1611 String[] assetTagNames)
1612 throws PortalException, SystemException {
1613
1614 User user = userPersistence.findByPrimaryKey(userId);
1615
1616 Company company = companyPersistence.findByPrimaryKey(
1617 user.getCompanyId());
1618
1619 Group companyGroup = company.getGroup();
1620
1621 assetEntryLocalService.updateEntry(
1622 userId, companyGroup.getGroupId(), null, null,
1623 Organization.class.getName(), organization.getOrganizationId(),
1624 organization.getUuid(), 0, assetCategoryIds, assetTagNames, false,
1625 null, null, null, null, organization.getName(), StringPool.BLANK,
1626 null, null, null, 0, 0, null, false);
1627 }
1628
1629
1659 @Override
1660 public Organization updateOrganization(
1661 long companyId, long organizationId, long parentOrganizationId,
1662 String name, String type, boolean recursable, long regionId,
1663 long countryId, int statusId, String comments, boolean site,
1664 ServiceContext serviceContext)
1665 throws PortalException, SystemException {
1666
1667 return updateOrganization(
1668 companyId, organizationId, parentOrganizationId, name, type,
1669 regionId, countryId, statusId, comments, site, serviceContext);
1670 }
1671
1672
1697 @Override
1698 public Organization updateOrganization(
1699 long companyId, long organizationId, long parentOrganizationId,
1700 String name, String type, long regionId, long countryId,
1701 int statusId, String comments, boolean site,
1702 ServiceContext serviceContext)
1703 throws PortalException, SystemException {
1704
1705
1706
1707 parentOrganizationId = getParentOrganizationId(
1708 companyId, parentOrganizationId);
1709
1710 validate(
1711 companyId, organizationId, parentOrganizationId, name, type,
1712 countryId, statusId);
1713
1714 Organization organization = organizationPersistence.findByPrimaryKey(
1715 organizationId);
1716
1717 long oldParentOrganizationId = organization.getParentOrganizationId();
1718 String oldName = organization.getName();
1719
1720 organization.setModifiedDate(new Date());
1721 organization.setParentOrganizationId(parentOrganizationId);
1722 organization.setTreePath(organization.buildTreePath());
1723 organization.setName(name);
1724 organization.setType(type);
1725 organization.setRecursable(true);
1726 organization.setRegionId(regionId);
1727 organization.setCountryId(countryId);
1728 organization.setStatusId(statusId);
1729 organization.setComments(comments);
1730 organization.setExpandoBridgeAttributes(serviceContext);
1731
1732 organizationPersistence.update(organization);
1733
1734
1735
1736 Group group = organization.getGroup();
1737
1738 long parentGroupId = group.getParentGroupId();
1739
1740 boolean organizationGroup = isOrganizationGroup(
1741 oldParentOrganizationId, group.getParentGroupId());
1742
1743 if (organizationGroup) {
1744 if (parentOrganizationId !=
1745 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1746
1747 Organization parentOrganization =
1748 organizationPersistence.fetchByPrimaryKey(
1749 parentOrganizationId);
1750
1751 Group parentGroup = parentOrganization.getGroup();
1752
1753 if (site && parentGroup.isSite()) {
1754 parentGroupId = parentOrganization.getGroupId();
1755 }
1756 else {
1757 parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
1758 }
1759 }
1760 else {
1761 parentGroupId = GroupConstants.DEFAULT_PARENT_GROUP_ID;
1762 }
1763 }
1764
1765 if (!oldName.equals(name) || organizationGroup) {
1766 groupLocalService.updateGroup(
1767 group.getGroupId(), parentGroupId, name, group.getDescription(),
1768 group.getType(), group.isManualMembership(),
1769 group.getMembershipRestriction(), group.getFriendlyURL(),
1770 group.isActive(), null);
1771 }
1772
1773 if (group.isSite() != site) {
1774 groupLocalService.updateSite(group.getGroupId(), site);
1775 }
1776
1777
1778
1779 if (serviceContext != null) {
1780 updateAsset(
1781 serviceContext.getUserId(), organization,
1782 serviceContext.getAssetCategoryIds(),
1783 serviceContext.getAssetTagNames());
1784 }
1785
1786
1787
1788 Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1789 Organization.class);
1790
1791 if (oldParentOrganizationId != parentOrganizationId) {
1792 long[] organizationIds = getReindexOrganizationIds(organization);
1793
1794 indexer.reindex(organizationIds);
1795 }
1796 else {
1797 indexer.reindex(organization);
1798 }
1799
1800 return organization;
1801 }
1802
1803 protected void addSuborganizations(
1804 List<Organization> allSuborganizations,
1805 List<Organization> organizations)
1806 throws SystemException {
1807
1808 for (Organization organization : organizations) {
1809 if (!allSuborganizations.contains(organization)) {
1810 allSuborganizations.add(organization);
1811
1812 List<Organization> suborganizations =
1813 organizationPersistence.findByC_P(
1814 organization.getCompanyId(),
1815 organization.getOrganizationId());
1816
1817 addSuborganizations(allSuborganizations, suborganizations);
1818 }
1819 }
1820 }
1821
1822 protected long getParentOrganizationId(
1823 long companyId, long parentOrganizationId)
1824 throws SystemException {
1825
1826 if (parentOrganizationId !=
1827 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1828
1829
1830
1831
1832 Organization parentOrganization =
1833 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
1834
1835 if ((parentOrganization == null) ||
1836 (companyId != parentOrganization.getCompanyId())) {
1837
1838 parentOrganizationId =
1839 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID;
1840 }
1841 }
1842
1843 return parentOrganizationId;
1844 }
1845
1846 protected long[] getReindexOrganizationIds(Organization organization)
1847 throws PortalException, SystemException {
1848
1849 List<Organization> organizations = organizationPersistence.findByC_T(
1850 organization.getCompanyId(),
1851 CustomSQLUtil.keywords(organization.getTreePath())[0],
1852 QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1853 new OrganizationNameComparator(true));
1854
1855 long[] organizationIds = new long[organizations.size()];
1856
1857 for (int i = 0; i < organizations.size(); i++) {
1858 Organization curOrganization = organizations.get(i);
1859
1860 curOrganization.setTreePath(curOrganization.buildTreePath());
1861
1862 organizationPersistence.update(curOrganization);
1863
1864 organizationIds[i] = curOrganization.getOrganizationId();
1865 }
1866
1867 if (!ArrayUtil.contains(
1868 organizationIds, organization.getOrganizationId())) {
1869
1870 organizationIds = ArrayUtil.append(
1871 organizationIds, organization.getOrganizationId());
1872 }
1873
1874 return organizationIds;
1875 }
1876
1877 protected boolean isOrganizationGroup(long organizationId, long groupId)
1878 throws SystemException {
1879
1880 if ((organizationId ==
1881 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) &&
1882 (groupId == GroupConstants.DEFAULT_PARENT_GROUP_ID)) {
1883
1884 return true;
1885 }
1886
1887 if (organizationId !=
1888 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1889
1890 Organization organization =
1891 organizationPersistence.fetchByPrimaryKey(organizationId);
1892
1893 if (organization.getGroupId() == groupId) {
1894 return true;
1895 }
1896 }
1897
1898 return false;
1899 }
1900
1901 protected boolean isParentOrganization(
1902 long parentOrganizationId, long organizationId)
1903 throws PortalException, SystemException {
1904
1905
1906
1907
1908 if (organizationId ==
1909 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1910
1911 return false;
1912 }
1913
1914 Organization organization = organizationPersistence.findByPrimaryKey(
1915 organizationId);
1916
1917 String treePath = organization.getTreePath();
1918
1919 if (treePath.contains(
1920 StringPool.SLASH + parentOrganizationId + StringPool.SLASH)) {
1921
1922 return true;
1923 }
1924 else {
1925 return false;
1926 }
1927 }
1928
1929 protected void validate(
1930 long companyId, long organizationId, long parentOrganizationId,
1931 String name, String type, long countryId, int statusId)
1932 throws PortalException, SystemException {
1933
1934 if (!ArrayUtil.contains(PropsValues.ORGANIZATIONS_TYPES, type)) {
1935 throw new OrganizationTypeException(
1936 "Invalid organization type " + type);
1937 }
1938
1939 if (parentOrganizationId ==
1940 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
1941
1942 if (!OrganizationImpl.isRootable(type)) {
1943 throw new OrganizationParentException(
1944 "Organization of type " + type + " cannot be a root");
1945 }
1946 }
1947 else {
1948 Organization parentOrganization =
1949 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
1950
1951 if (parentOrganization == null) {
1952 throw new OrganizationParentException(
1953 "Organization " + parentOrganizationId + " doesn't exist");
1954 }
1955
1956 String[] childrenTypes = OrganizationImpl.getChildrenTypes(
1957 parentOrganization.getType());
1958
1959 if (childrenTypes.length == 0) {
1960 throw new OrganizationParentException(
1961 "Organization of type " + type + " cannot have children");
1962 }
1963
1964 if ((companyId != parentOrganization.getCompanyId()) ||
1965 (parentOrganizationId == organizationId)) {
1966
1967 throw new OrganizationParentException();
1968 }
1969
1970 if (!ArrayUtil.contains(childrenTypes, type)) {
1971 throw new OrganizationParentException(
1972 "Type " + type + " not allowed as child of " +
1973 parentOrganization.getType());
1974 }
1975 }
1976
1977 if ((organizationId > 0) &&
1978 (parentOrganizationId !=
1979 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID)) {
1980
1981
1982
1983 if (isParentOrganization(organizationId, parentOrganizationId)) {
1984 throw new OrganizationParentException();
1985 }
1986 }
1987
1988 if (Validator.isNull(name)) {
1989 throw new OrganizationNameException();
1990 }
1991 else {
1992 Organization organization = organizationPersistence.fetchByC_N(
1993 companyId, name);
1994
1995 if ((organization != null) &&
1996 StringUtil.equalsIgnoreCase(organization.getName(), name)) {
1997
1998 if ((organizationId <= 0) ||
1999 (organization.getOrganizationId() != organizationId)) {
2000
2001 throw new DuplicateOrganizationException(
2002 "There is another organization named " + name);
2003 }
2004 }
2005 }
2006
2007 boolean countryRequired = GetterUtil.getBoolean(
2008 PropsUtil.get(
2009 PropsKeys.ORGANIZATIONS_COUNTRY_REQUIRED, new Filter(type)));
2010
2011 if (countryRequired || (countryId > 0)) {
2012 countryPersistence.findByPrimaryKey(countryId);
2013 }
2014
2015 listTypeService.validate(
2016 statusId, ListTypeConstants.ORGANIZATION_STATUS);
2017 }
2018
2019 protected void validate(
2020 long companyId, long parentOrganizationId, String name, String type,
2021 long countryId, int statusId)
2022 throws PortalException, SystemException {
2023
2024 validate(
2025 companyId, 0, parentOrganizationId, name, type, countryId,
2026 statusId);
2027 }
2028
2029 }