1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
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  /**
56   * <a href="OrganizationLocalServiceImpl.java.html"><b><i>View Source</i></b>
57   * </a>
58   *
59   * @author Brian Wing Shun Chan
60   * @author Jorge Ferrer
61   *
62   */
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          // Organization
81  
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         // Group
116 
117         Group group = groupLocalService.addGroup(
118             userId, Organization.class.getName(), organizationId, null, null, 0,
119             null, true);
120 
121         // Role
122 
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         // User
130 
131         userPersistence.addOrganization(userId, organizationId);
132 
133         // Resources
134 
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         // Addresses
178 
179         addressLocalService.deleteAddresses(
180             organization.getCompanyId(), Organization.class.getName(),
181             organization.getOrganizationId());
182 
183         // Email addresses
184 
185         emailAddressLocalService.deleteEmailAddresses(
186             organization.getCompanyId(), Organization.class.getName(),
187             organization.getOrganizationId());
188 
189         // Password policy relation
190 
191         passwordPolicyRelLocalService.deletePasswordPolicyRel(
192             Organization.class.getName(), organization.getOrganizationId());
193 
194         // Phone
195 
196         phoneLocalService.deletePhones(
197             organization.getCompanyId(), Organization.class.getName(),
198             organization.getOrganizationId());
199 
200         // Website
201 
202         websiteLocalService.deleteWebsites(
203             organization.getCompanyId(), Organization.class.getName(),
204             organization.getOrganizationId());
205 
206         // Group
207 
208         Group group = organization.getGroup();
209 
210         groupLocalService.deleteGroup(group.getGroupId());
211 
212         // Resources
213 
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         // Organization
226 
227         organizationPersistence.remove(organization);
228 
229         // Permission cache
230 
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             // Ensure parent organization exists and belongs to the proper
575             // company
576 
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         // Return true if parentOrganizationId is among the parent organizatons
625         // of organizationId
626 
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             // Prevent circular organizational references
678 
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 }