1
22
23 package com.liferay.portal.service.impl;
24
25 import com.liferay.portal.DuplicateOrganizationException;
26 import com.liferay.portal.OrganizationNameException;
27 import com.liferay.portal.OrganizationParentException;
28 import com.liferay.portal.PortalException;
29 import com.liferay.portal.RequiredOrganizationException;
30 import com.liferay.portal.SystemException;
31 import com.liferay.portal.kernel.util.OrderByComparator;
32 import com.liferay.portal.kernel.util.StringPool;
33 import com.liferay.portal.kernel.util.Validator;
34 import com.liferay.portal.model.Group;
35 import com.liferay.portal.model.Location;
36 import com.liferay.portal.model.Organization;
37 import com.liferay.portal.model.OrganizationConstants;
38 import com.liferay.portal.model.ResourceConstants;
39 import com.liferay.portal.model.Role;
40 import com.liferay.portal.model.RoleConstants;
41 import com.liferay.portal.model.User;
42 import com.liferay.portal.model.impl.ListTypeImpl;
43 import com.liferay.portal.security.permission.PermissionCacheUtil;
44 import com.liferay.portal.service.base.OrganizationLocalServiceBaseImpl;
45 import com.liferay.portal.util.PropsValues;
46 import com.liferay.portal.util.comparator.OrganizationNameComparator;
47
48 import java.rmi.RemoteException;
49
50 import java.util.ArrayList;
51 import java.util.Iterator;
52 import java.util.LinkedHashMap;
53 import java.util.List;
54
55
63 public class OrganizationLocalServiceImpl
64 extends OrganizationLocalServiceBaseImpl {
65
66 public void addGroupOrganizations(long groupId, long[] organizationIds)
67 throws SystemException {
68
69 groupPersistence.addOrganizations(groupId, organizationIds);
70
71 PermissionCacheUtil.clearCache();
72 }
73
74 public Organization addOrganization(
75 long userId, long parentOrganizationId, String name,
76 int type, boolean recursable, long regionId, long countryId,
77 int statusId, String comments)
78 throws PortalException, SystemException {
79
80
82 User user = userPersistence.findByPrimaryKey(userId);
83 parentOrganizationId = getParentOrganizationId(
84 user.getCompanyId(), parentOrganizationId);
85 recursable = true;
86
87 validate(
88 user.getCompanyId(), parentOrganizationId, name, type, countryId,
89 statusId);
90
91 long organizationId = counterLocalService.increment();
92
93 Organization organization = organizationPersistence.create(
94 organizationId);
95
96 organization.setCompanyId(user.getCompanyId());
97 organization.setParentOrganizationId(parentOrganizationId);
98 organization.setName(name);
99
100 if (type == OrganizationConstants.TYPE_LOCATION) {
101 organization.setLocation(true);
102 }
103 else {
104 organization.setLocation(false);
105 }
106
107 organization.setRecursable(recursable);
108 organization.setRegionId(regionId);
109 organization.setCountryId(countryId);
110 organization.setStatusId(statusId);
111 organization.setComments(comments);
112
113 organizationPersistence.update(organization, false);
114
115
117 Group group = groupLocalService.addGroup(
118 userId, Organization.class.getName(), organizationId, null, null, 0,
119 null, true);
120
121
123 Role role = roleLocalService.getRole(
124 organization.getCompanyId(), RoleConstants.ORGANIZATION_OWNER);
125
126 userGroupRoleLocalService.addUserGroupRoles(
127 userId, group.getGroupId(), new long[] {role.getRoleId()});
128
129
131 userPersistence.addOrganization(userId, organizationId);
132
133
135 addOrganizationResources(userId, organization);
136
137 return organization;
138 }
139
140 public void addOrganizationResources(long userId, Organization organization)
141 throws PortalException, SystemException {
142
143 String name = Organization.class.getName();
144
145 if (organization.isLocation()) {
146 name = Location.class.getName();
147 }
148
149 resourceLocalService.addResources(
150 organization.getCompanyId(), 0, userId, name,
151 organization.getOrganizationId(), false, false, false);
152 }
153
154 public void addPasswordPolicyOrganizations(
155 long passwordPolicyId, long[] organizationIds)
156 throws SystemException {
157
158 passwordPolicyRelLocalService.addPasswordPolicyRels(
159 passwordPolicyId, Organization.class.getName(), organizationIds);
160 }
161
162 public void deleteOrganization(long organizationId)
163 throws PortalException, SystemException {
164
165 Organization organization = organizationPersistence.findByPrimaryKey(
166 organizationId);
167
168 if ((userLocalService.getOrganizationUsersCount(
169 organization.getOrganizationId(), true) > 0) ||
170 (organizationPersistence.countByC_P(
171 organization.getCompanyId(),
172 organization.getOrganizationId()) > 0)) {
173
174 throw new RequiredOrganizationException();
175 }
176
177
179 addressLocalService.deleteAddresses(
180 organization.getCompanyId(), Organization.class.getName(),
181 organization.getOrganizationId());
182
183
185 emailAddressLocalService.deleteEmailAddresses(
186 organization.getCompanyId(), Organization.class.getName(),
187 organization.getOrganizationId());
188
189
191 passwordPolicyRelLocalService.deletePasswordPolicyRel(
192 Organization.class.getName(), organization.getOrganizationId());
193
194
196 phoneLocalService.deletePhones(
197 organization.getCompanyId(), Organization.class.getName(),
198 organization.getOrganizationId());
199
200
202 websiteLocalService.deleteWebsites(
203 organization.getCompanyId(), Organization.class.getName(),
204 organization.getOrganizationId());
205
206
208 Group group = organization.getGroup();
209
210 groupLocalService.deleteGroup(group.getGroupId());
211
212
214 String name = Organization.class.getName();
215
216 if (organization.isLocation()) {
217 name = Location.class.getName();
218 }
219
220 resourceLocalService.deleteResource(
221 organization.getCompanyId(), name,
222 ResourceConstants.SCOPE_INDIVIDUAL,
223 organization.getOrganizationId());
224
225
227 organizationPersistence.remove(organization);
228
229
231 PermissionCacheUtil.clearCache();
232 }
233
234 public List<Organization> getGroupOrganizations(long groupId)
235 throws SystemException {
236
237 return groupPersistence.getOrganizations(groupId);
238 }
239
240 public Organization getOrganization(long organizationId)
241 throws PortalException, SystemException {
242
243 return organizationPersistence.findByPrimaryKey(organizationId);
244 }
245
246 public Organization getOrganization(long companyId, String name)
247 throws PortalException, SystemException {
248
249 return organizationPersistence.findByC_N(companyId, name);
250 }
251
252 public long getOrganizationId(long companyId, String name)
253 throws SystemException {
254
255 Organization organization = organizationPersistence.fetchByC_N(
256 companyId, name);
257
258 if (organization != null) {
259 return organization.getOrganizationId();
260 }
261 else {
262 return 0;
263 }
264 }
265
266 public List<Organization> getOrganizations(long[] organizationIds)
267 throws PortalException, SystemException {
268
269 List<Organization> organizations = new ArrayList<Organization>();
270
271 for (int i = 0; i < organizationIds.length; i++) {
272 Organization organization = getOrganization(organizationIds[i]);
273
274 organizations.add(organization);
275 }
276
277 return organizations;
278 }
279
280 public List<Organization> getParentOrganizations(long organizationId)
281 throws PortalException, SystemException {
282
283 if (organizationId ==
284 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
285
286 return new ArrayList<Organization>();
287 }
288
289 Organization organization =
290 organizationPersistence.findByPrimaryKey(organizationId);
291
292 return getParentOrganizations(organization, true);
293 }
294
295 public List<Organization> getSuborganizations(
296 List<Organization> organizations)
297 throws SystemException {
298
299 List<Organization> allSuborganizations = new ArrayList<Organization>();
300
301 for (int i = 0; i < organizations.size(); i++) {
302 Organization organization = organizations.get(i);
303
304 List<Organization> suborganizations =
305 organizationPersistence.findByC_P(
306 organization.getCompanyId(),
307 organization.getOrganizationId());
308
309 addSuborganizations(allSuborganizations, suborganizations);
310 }
311
312 return allSuborganizations;
313 }
314
315 public List<Organization> getSubsetOrganizations(
316 List<Organization> allOrganizations,
317 List<Organization> availableOrganizations) {
318
319 List<Organization> subsetOrganizations = new ArrayList<Organization>();
320
321 Iterator<Organization> itr = allOrganizations.iterator();
322
323 while (itr.hasNext()) {
324 Organization organization = itr.next();
325
326 if (availableOrganizations.contains(organization)) {
327 subsetOrganizations.add(organization);
328 }
329 }
330
331 return subsetOrganizations;
332 }
333
334 public List<Organization> getUserOrganizations(long userId)
335 throws SystemException {
336
337 return userPersistence.getOrganizations(userId);
338 }
339
340 public List<Organization> getUserOrganizations(
341 long userId, int start, int end)
342 throws SystemException {
343
344 return userPersistence.getOrganizations(userId, start, end);
345 }
346
347 public int getUserOrganizationsCount(long userId) throws SystemException {
348 return userPersistence.getOrganizationsSize(userId);
349 }
350
351 public boolean hasGroupOrganization(long groupId, long organizationId)
352 throws SystemException {
353
354 return groupPersistence.containsOrganization(groupId, organizationId);
355 }
356
357 public boolean hasUserOrganization(long userId, long organizationId)
358 throws SystemException {
359
360 return userPersistence.containsOrganization(userId, organizationId);
361 }
362
363 public boolean hasPasswordPolicyOrganization(
364 long passwordPolicyId, long organizationId)
365 throws SystemException {
366
367 return passwordPolicyRelLocalService.hasPasswordPolicyRel(
368 passwordPolicyId, Organization.class.getName(), organizationId);
369 }
370
371 public void rebuildTree(long companyId, boolean force)
372 throws SystemException {
373
374 organizationPersistence.rebuildTree(companyId, force);
375 }
376
377 public List<Organization> search(
378 long companyId, long parentOrganizationId, String keywords,
379 int type, Long regionId, Long countryId,
380 LinkedHashMap<String, Object> params,
381 int start, int end)
382 throws SystemException {
383
384 return search(
385 companyId, parentOrganizationId, keywords, type, regionId,
386 countryId, params, start, end,
387 new OrganizationNameComparator(true));
388 }
389
390 public List<Organization> search(
391 long companyId, long parentOrganizationId, String keywords,
392 int type, Long regionId, Long countryId,
393 LinkedHashMap<String, Object> params,
394 int start, int end, OrderByComparator obc)
395 throws SystemException {
396
397 String parentOrganizationIdComparator = StringPool.EQUAL;
398
399 if (parentOrganizationId ==
400 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
401
402 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
403 }
404
405 return organizationFinder.findByKeywords(
406 companyId, parentOrganizationId, parentOrganizationIdComparator,
407 keywords, type, regionId, countryId, params, start, end,
408 obc);
409 }
410
411 public List<Organization> search(
412 long companyId, long parentOrganizationId, String name, int type,
413 String street, String city, String zip,
414 Long regionId, Long countryId,
415 LinkedHashMap<String, Object> params, boolean andOperator,
416 int start, int end)
417 throws SystemException {
418
419 return search(
420 companyId, parentOrganizationId, name, type, street, city, zip,
421 regionId, countryId, params, andOperator, start, end,
422 new OrganizationNameComparator(true));
423 }
424
425 public List<Organization> search(
426 long companyId, long parentOrganizationId, String name, int type,
427 String street, String city, String zip,
428 Long regionId, Long countryId, LinkedHashMap<String, Object> params,
429 boolean andOperator, int start, int end, OrderByComparator obc)
430 throws SystemException {
431
432 String parentOrganizationIdComparator = StringPool.EQUAL;
433
434 if (parentOrganizationId ==
435 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
436
437 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
438 }
439
440 return organizationFinder.findByC_PO_N_T_S_C_Z_R_C(
441 companyId, parentOrganizationId, parentOrganizationIdComparator,
442 name, type, street, city, zip, regionId, countryId, params,
443 andOperator, start, end, obc);
444 }
445
446 public int searchCount(
447 long companyId, long parentOrganizationId, String keywords,
448 int type, Long regionId, Long countryId,
449 LinkedHashMap<String, Object> params)
450 throws SystemException {
451
452 String parentOrganizationIdComparator = StringPool.EQUAL;
453
454 if (parentOrganizationId ==
455 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
456
457 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
458 }
459
460 return organizationFinder.countByKeywords(
461 companyId, parentOrganizationId, parentOrganizationIdComparator,
462 keywords, type, regionId, countryId, params);
463 }
464
465 public int searchCount(
466 long companyId, long parentOrganizationId, String name, int type,
467 String street, String city, String zip,
468 Long regionId, Long countryId, LinkedHashMap<String, Object> params,
469 boolean andOperator)
470 throws SystemException {
471
472 String parentOrganizationIdComparator = StringPool.EQUAL;
473
474 if (parentOrganizationId ==
475 OrganizationConstants.ANY_PARENT_ORGANIZATION_ID) {
476
477 parentOrganizationIdComparator = StringPool.NOT_EQUAL;
478 }
479
480 return organizationFinder.countByC_PO_N_T_S_C_Z_R_C(
481 companyId, parentOrganizationId, parentOrganizationIdComparator,
482 name, type, street, city, zip, regionId, countryId, params,
483 andOperator);
484 }
485
486 public void setGroupOrganizations(long groupId, long[] organizationIds)
487 throws SystemException {
488
489 groupPersistence.setOrganizations(groupId, organizationIds);
490
491 PermissionCacheUtil.clearCache();
492 }
493
494 public void unsetGroupOrganizations(long groupId, long[] organizationIds)
495 throws SystemException {
496
497 groupPersistence.removeOrganizations(groupId, organizationIds);
498
499 PermissionCacheUtil.clearCache();
500 }
501
502 public void unsetPasswordPolicyOrganizations(
503 long passwordPolicyId, long[] organizationIds)
504 throws SystemException {
505
506 passwordPolicyRelLocalService.deletePasswordPolicyRels(
507 passwordPolicyId, Organization.class.getName(), organizationIds);
508 }
509
510 public Organization updateOrganization(
511 long companyId, long organizationId, long parentOrganizationId,
512 String name, int type, boolean recursable, long regionId,
513 long countryId, int statusId, String comments)
514 throws PortalException, SystemException {
515
516 parentOrganizationId = getParentOrganizationId(
517 companyId, parentOrganizationId);
518 recursable = true;
519
520 validate(
521 companyId, organizationId, parentOrganizationId, name, type,
522 countryId, statusId);
523
524 Organization organization = organizationPersistence.findByPrimaryKey(
525 organizationId);
526
527 organization.setParentOrganizationId(parentOrganizationId);
528 organization.setName(name);
529
530 if (type == OrganizationConstants.TYPE_LOCATION) {
531 organization.setLocation(true);
532 }
533 else {
534 organization.setLocation(false);
535 }
536
537 organization.setRecursable(recursable);
538 organization.setRegionId(regionId);
539 organization.setCountryId(countryId);
540 organization.setStatusId(statusId);
541 organization.setComments(comments);
542
543 organizationPersistence.update(organization, false);
544
545 return organization;
546 }
547
548 protected void addSuborganizations(
549 List<Organization> allSuborganizations,
550 List<Organization> organizations)
551 throws SystemException {
552
553 for (Organization organization : organizations) {
554 if (!allSuborganizations.contains(organization)) {
555 allSuborganizations.add(organization);
556
557 List<Organization> suborganizations =
558 organizationPersistence.findByC_P(
559 organization.getCompanyId(),
560 organization.getOrganizationId());
561
562 addSuborganizations(allSuborganizations, suborganizations);
563 }
564 }
565 }
566
567 protected long getParentOrganizationId(
568 long companyId, long parentOrganizationId)
569 throws SystemException {
570
571 if (parentOrganizationId !=
572 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
573
574
577 Organization parentOrganization =
578 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
579
580 if ((parentOrganization == null) ||
581 (companyId != parentOrganization.getCompanyId())) {
582
583 parentOrganizationId =
584 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID;
585 }
586 }
587
588 return parentOrganizationId;
589 }
590
591 protected List<Organization> getParentOrganizations(
592 Organization organization, boolean lastOrganization)
593 throws PortalException, SystemException {
594
595 List<Organization> organizations = new ArrayList<Organization>();
596
597 if (!lastOrganization) {
598 organizations.add(organization);
599 }
600
601 long parentOrganizationId = organization.getParentOrganizationId();
602
603 if (parentOrganizationId ==
604 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
605
606 return organizations;
607 }
608
609 Organization parentOrganization =
610 organizationPersistence.findByPrimaryKey(parentOrganizationId);
611
612 List<Organization> parentOrganizatons = getParentOrganizations(
613 parentOrganization, false);
614
615 organizations.addAll(parentOrganizatons);
616
617 return organizations;
618 }
619
620 protected boolean isParentOrganization(
621 long parentOrganizationId, long organizationId)
622 throws PortalException, SystemException {
623
624
627 Organization parentOrganization =
628 organizationPersistence.findByPrimaryKey(
629 parentOrganizationId);
630
631 List<Organization> parentOrganizations = getParentOrganizations(
632 organizationId);
633
634 if (parentOrganizations.contains(parentOrganization)) {
635 return true;
636 }
637 else {
638 return false;
639 }
640 }
641
642 protected void validate(
643 long companyId, long parentOrganizationId, String name, int type,
644 long countryId, int statusId)
645 throws PortalException, SystemException {
646
647 validate(
648 companyId, 0, parentOrganizationId, name, type, countryId,
649 statusId);
650 }
651
652 protected void validate(
653 long companyId, long organizationId, long parentOrganizationId,
654 String name, int type, long countryId, int statusId)
655 throws PortalException, SystemException {
656
657 if ((type == OrganizationConstants.TYPE_LOCATION) ||
658 (parentOrganizationId !=
659 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID)) {
660
661 Organization parentOrganization =
662 organizationPersistence.fetchByPrimaryKey(parentOrganizationId);
663
664 if ((parentOrganization == null) ||
665 (companyId != parentOrganization.getCompanyId()) ||
666 (parentOrganizationId == organizationId) ||
667 (parentOrganization.isLocation())) {
668
669 throw new OrganizationParentException();
670 }
671 }
672
673 if ((organizationId > 0) &&
674 (parentOrganizationId !=
675 OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID)) {
676
677
679 if (isParentOrganization(organizationId, parentOrganizationId)) {
680 throw new OrganizationParentException();
681 }
682 }
683
684 if (Validator.isNull(name)) {
685 throw new OrganizationNameException();
686 }
687 else {
688 Organization organization = organizationPersistence.fetchByC_N(
689 companyId, name);
690
691 if ((organization != null) &&
692 (organization.getName().equalsIgnoreCase(name))) {
693
694 if ((organizationId <= 0) ||
695 (organization.getOrganizationId() != organizationId)) {
696
697 throw new DuplicateOrganizationException();
698 }
699 }
700 }
701
702 try {
703 if ((countryId > 0) || PropsValues.ORGANIZATIONS_COUNTRY_REQUIRED) {
704 countryPersistence.findByPrimaryKey(countryId);
705 }
706
707 listTypeService.validate(
708 statusId, ListTypeImpl.ORGANIZATION_STATUS);
709 }
710 catch (RemoteException re) {
711 throw new SystemException(re);
712 }
713 }
714
715 }