001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.model.Organization;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the organization service. This utility wraps {@link com.liferay.portal.service.persistence.impl.OrganizationPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see OrganizationPersistence
037     * @see com.liferay.portal.service.persistence.impl.OrganizationPersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class OrganizationUtil {
042            /*
043             * NOTE FOR DEVELOPERS:
044             *
045             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
046             */
047    
048            /**
049             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
050             */
051            public static void clearCache() {
052                    getPersistence().clearCache();
053            }
054    
055            /**
056             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
057             */
058            public static void clearCache(Organization organization) {
059                    getPersistence().clearCache(organization);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
064             */
065            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<Organization> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<Organization> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end) {
082                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
083            }
084    
085            /**
086             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
087             */
088            public static List<Organization> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator<Organization> orderByComparator) {
091                    return getPersistence()
092                                       .findWithDynamicQuery(dynamicQuery, start, end,
093                            orderByComparator);
094            }
095    
096            /**
097             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
098             */
099            public static Organization update(Organization organization) {
100                    return getPersistence().update(organization);
101            }
102    
103            /**
104             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
105             */
106            public static Organization update(Organization organization,
107                    ServiceContext serviceContext) {
108                    return getPersistence().update(organization, serviceContext);
109            }
110    
111            /**
112            * Returns all the organizations where uuid = &#63;.
113            *
114            * @param uuid the uuid
115            * @return the matching organizations
116            */
117            public static List<Organization> findByUuid(java.lang.String uuid) {
118                    return getPersistence().findByUuid(uuid);
119            }
120    
121            /**
122            * Returns a range of all the organizations where uuid = &#63;.
123            *
124            * <p>
125            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
126            * </p>
127            *
128            * @param uuid the uuid
129            * @param start the lower bound of the range of organizations
130            * @param end the upper bound of the range of organizations (not inclusive)
131            * @return the range of matching organizations
132            */
133            public static List<Organization> findByUuid(java.lang.String uuid,
134                    int start, int end) {
135                    return getPersistence().findByUuid(uuid, start, end);
136            }
137    
138            /**
139            * Returns an ordered range of all the organizations where uuid = &#63;.
140            *
141            * <p>
142            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
143            * </p>
144            *
145            * @param uuid the uuid
146            * @param start the lower bound of the range of organizations
147            * @param end the upper bound of the range of organizations (not inclusive)
148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
149            * @return the ordered range of matching organizations
150            */
151            public static List<Organization> findByUuid(java.lang.String uuid,
152                    int start, int end, OrderByComparator<Organization> orderByComparator) {
153                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
154            }
155    
156            /**
157            * Returns an ordered range of all the organizations where uuid = &#63;.
158            *
159            * <p>
160            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
161            * </p>
162            *
163            * @param uuid the uuid
164            * @param start the lower bound of the range of organizations
165            * @param end the upper bound of the range of organizations (not inclusive)
166            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
167            * @param retrieveFromCache whether to retrieve from the finder cache
168            * @return the ordered range of matching organizations
169            */
170            public static List<Organization> findByUuid(java.lang.String uuid,
171                    int start, int end, OrderByComparator<Organization> orderByComparator,
172                    boolean retrieveFromCache) {
173                    return getPersistence()
174                                       .findByUuid(uuid, start, end, orderByComparator,
175                            retrieveFromCache);
176            }
177    
178            /**
179            * Returns the first organization in the ordered set where uuid = &#63;.
180            *
181            * @param uuid the uuid
182            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
183            * @return the first matching organization
184            * @throws NoSuchOrganizationException if a matching organization could not be found
185            */
186            public static Organization findByUuid_First(java.lang.String uuid,
187                    OrderByComparator<Organization> orderByComparator)
188                    throws com.liferay.portal.exception.NoSuchOrganizationException {
189                    return getPersistence().findByUuid_First(uuid, orderByComparator);
190            }
191    
192            /**
193            * Returns the first organization in the ordered set where uuid = &#63;.
194            *
195            * @param uuid the uuid
196            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
197            * @return the first matching organization, or <code>null</code> if a matching organization could not be found
198            */
199            public static Organization fetchByUuid_First(java.lang.String uuid,
200                    OrderByComparator<Organization> orderByComparator) {
201                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
202            }
203    
204            /**
205            * Returns the last organization in the ordered set where uuid = &#63;.
206            *
207            * @param uuid the uuid
208            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
209            * @return the last matching organization
210            * @throws NoSuchOrganizationException if a matching organization could not be found
211            */
212            public static Organization findByUuid_Last(java.lang.String uuid,
213                    OrderByComparator<Organization> orderByComparator)
214                    throws com.liferay.portal.exception.NoSuchOrganizationException {
215                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
216            }
217    
218            /**
219            * Returns the last organization in the ordered set where uuid = &#63;.
220            *
221            * @param uuid the uuid
222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
223            * @return the last matching organization, or <code>null</code> if a matching organization could not be found
224            */
225            public static Organization fetchByUuid_Last(java.lang.String uuid,
226                    OrderByComparator<Organization> orderByComparator) {
227                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
228            }
229    
230            /**
231            * Returns the organizations before and after the current organization in the ordered set where uuid = &#63;.
232            *
233            * @param organizationId the primary key of the current organization
234            * @param uuid the uuid
235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
236            * @return the previous, current, and next organization
237            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
238            */
239            public static Organization[] findByUuid_PrevAndNext(long organizationId,
240                    java.lang.String uuid, OrderByComparator<Organization> orderByComparator)
241                    throws com.liferay.portal.exception.NoSuchOrganizationException {
242                    return getPersistence()
243                                       .findByUuid_PrevAndNext(organizationId, uuid,
244                            orderByComparator);
245            }
246    
247            /**
248            * Returns all the organizations that the user has permission to view where uuid = &#63;.
249            *
250            * @param uuid the uuid
251            * @return the matching organizations that the user has permission to view
252            */
253            public static List<Organization> filterFindByUuid(java.lang.String uuid) {
254                    return getPersistence().filterFindByUuid(uuid);
255            }
256    
257            /**
258            * Returns a range of all the organizations that the user has permission to view where uuid = &#63;.
259            *
260            * <p>
261            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
262            * </p>
263            *
264            * @param uuid the uuid
265            * @param start the lower bound of the range of organizations
266            * @param end the upper bound of the range of organizations (not inclusive)
267            * @return the range of matching organizations that the user has permission to view
268            */
269            public static List<Organization> filterFindByUuid(java.lang.String uuid,
270                    int start, int end) {
271                    return getPersistence().filterFindByUuid(uuid, start, end);
272            }
273    
274            /**
275            * Returns an ordered range of all the organizations that the user has permissions to view where uuid = &#63;.
276            *
277            * <p>
278            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
279            * </p>
280            *
281            * @param uuid the uuid
282            * @param start the lower bound of the range of organizations
283            * @param end the upper bound of the range of organizations (not inclusive)
284            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
285            * @return the ordered range of matching organizations that the user has permission to view
286            */
287            public static List<Organization> filterFindByUuid(java.lang.String uuid,
288                    int start, int end, OrderByComparator<Organization> orderByComparator) {
289                    return getPersistence()
290                                       .filterFindByUuid(uuid, start, end, orderByComparator);
291            }
292    
293            /**
294            * Returns the organizations before and after the current organization in the ordered set of organizations that the user has permission to view where uuid = &#63;.
295            *
296            * @param organizationId the primary key of the current organization
297            * @param uuid the uuid
298            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
299            * @return the previous, current, and next organization
300            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
301            */
302            public static Organization[] filterFindByUuid_PrevAndNext(
303                    long organizationId, java.lang.String uuid,
304                    OrderByComparator<Organization> orderByComparator)
305                    throws com.liferay.portal.exception.NoSuchOrganizationException {
306                    return getPersistence()
307                                       .filterFindByUuid_PrevAndNext(organizationId, uuid,
308                            orderByComparator);
309            }
310    
311            /**
312            * Removes all the organizations where uuid = &#63; from the database.
313            *
314            * @param uuid the uuid
315            */
316            public static void removeByUuid(java.lang.String uuid) {
317                    getPersistence().removeByUuid(uuid);
318            }
319    
320            /**
321            * Returns the number of organizations where uuid = &#63;.
322            *
323            * @param uuid the uuid
324            * @return the number of matching organizations
325            */
326            public static int countByUuid(java.lang.String uuid) {
327                    return getPersistence().countByUuid(uuid);
328            }
329    
330            /**
331            * Returns the number of organizations that the user has permission to view where uuid = &#63;.
332            *
333            * @param uuid the uuid
334            * @return the number of matching organizations that the user has permission to view
335            */
336            public static int filterCountByUuid(java.lang.String uuid) {
337                    return getPersistence().filterCountByUuid(uuid);
338            }
339    
340            /**
341            * Returns all the organizations where uuid = &#63; and companyId = &#63;.
342            *
343            * @param uuid the uuid
344            * @param companyId the company ID
345            * @return the matching organizations
346            */
347            public static List<Organization> findByUuid_C(java.lang.String uuid,
348                    long companyId) {
349                    return getPersistence().findByUuid_C(uuid, companyId);
350            }
351    
352            /**
353            * Returns a range of all the organizations where uuid = &#63; and companyId = &#63;.
354            *
355            * <p>
356            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
357            * </p>
358            *
359            * @param uuid the uuid
360            * @param companyId the company ID
361            * @param start the lower bound of the range of organizations
362            * @param end the upper bound of the range of organizations (not inclusive)
363            * @return the range of matching organizations
364            */
365            public static List<Organization> findByUuid_C(java.lang.String uuid,
366                    long companyId, int start, int end) {
367                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
368            }
369    
370            /**
371            * Returns an ordered range of all the organizations where uuid = &#63; and companyId = &#63;.
372            *
373            * <p>
374            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
375            * </p>
376            *
377            * @param uuid the uuid
378            * @param companyId the company ID
379            * @param start the lower bound of the range of organizations
380            * @param end the upper bound of the range of organizations (not inclusive)
381            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
382            * @return the ordered range of matching organizations
383            */
384            public static List<Organization> findByUuid_C(java.lang.String uuid,
385                    long companyId, int start, int end,
386                    OrderByComparator<Organization> orderByComparator) {
387                    return getPersistence()
388                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
389            }
390    
391            /**
392            * Returns an ordered range of all the organizations where uuid = &#63; and companyId = &#63;.
393            *
394            * <p>
395            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
396            * </p>
397            *
398            * @param uuid the uuid
399            * @param companyId the company ID
400            * @param start the lower bound of the range of organizations
401            * @param end the upper bound of the range of organizations (not inclusive)
402            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
403            * @param retrieveFromCache whether to retrieve from the finder cache
404            * @return the ordered range of matching organizations
405            */
406            public static List<Organization> findByUuid_C(java.lang.String uuid,
407                    long companyId, int start, int end,
408                    OrderByComparator<Organization> orderByComparator,
409                    boolean retrieveFromCache) {
410                    return getPersistence()
411                                       .findByUuid_C(uuid, companyId, start, end,
412                            orderByComparator, retrieveFromCache);
413            }
414    
415            /**
416            * Returns the first organization in the ordered set where uuid = &#63; and companyId = &#63;.
417            *
418            * @param uuid the uuid
419            * @param companyId the company ID
420            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
421            * @return the first matching organization
422            * @throws NoSuchOrganizationException if a matching organization could not be found
423            */
424            public static Organization findByUuid_C_First(java.lang.String uuid,
425                    long companyId, OrderByComparator<Organization> orderByComparator)
426                    throws com.liferay.portal.exception.NoSuchOrganizationException {
427                    return getPersistence()
428                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
429            }
430    
431            /**
432            * Returns the first organization in the ordered set where uuid = &#63; and companyId = &#63;.
433            *
434            * @param uuid the uuid
435            * @param companyId the company ID
436            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
437            * @return the first matching organization, or <code>null</code> if a matching organization could not be found
438            */
439            public static Organization fetchByUuid_C_First(java.lang.String uuid,
440                    long companyId, OrderByComparator<Organization> orderByComparator) {
441                    return getPersistence()
442                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
443            }
444    
445            /**
446            * Returns the last organization in the ordered set where uuid = &#63; and companyId = &#63;.
447            *
448            * @param uuid the uuid
449            * @param companyId the company ID
450            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
451            * @return the last matching organization
452            * @throws NoSuchOrganizationException if a matching organization could not be found
453            */
454            public static Organization findByUuid_C_Last(java.lang.String uuid,
455                    long companyId, OrderByComparator<Organization> orderByComparator)
456                    throws com.liferay.portal.exception.NoSuchOrganizationException {
457                    return getPersistence()
458                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
459            }
460    
461            /**
462            * Returns the last organization in the ordered set where uuid = &#63; and companyId = &#63;.
463            *
464            * @param uuid the uuid
465            * @param companyId the company ID
466            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
467            * @return the last matching organization, or <code>null</code> if a matching organization could not be found
468            */
469            public static Organization fetchByUuid_C_Last(java.lang.String uuid,
470                    long companyId, OrderByComparator<Organization> orderByComparator) {
471                    return getPersistence()
472                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
473            }
474    
475            /**
476            * Returns the organizations before and after the current organization in the ordered set where uuid = &#63; and companyId = &#63;.
477            *
478            * @param organizationId the primary key of the current organization
479            * @param uuid the uuid
480            * @param companyId the company ID
481            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
482            * @return the previous, current, and next organization
483            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
484            */
485            public static Organization[] findByUuid_C_PrevAndNext(long organizationId,
486                    java.lang.String uuid, long companyId,
487                    OrderByComparator<Organization> orderByComparator)
488                    throws com.liferay.portal.exception.NoSuchOrganizationException {
489                    return getPersistence()
490                                       .findByUuid_C_PrevAndNext(organizationId, uuid, companyId,
491                            orderByComparator);
492            }
493    
494            /**
495            * Returns all the organizations that the user has permission to view where uuid = &#63; and companyId = &#63;.
496            *
497            * @param uuid the uuid
498            * @param companyId the company ID
499            * @return the matching organizations that the user has permission to view
500            */
501            public static List<Organization> filterFindByUuid_C(java.lang.String uuid,
502                    long companyId) {
503                    return getPersistence().filterFindByUuid_C(uuid, companyId);
504            }
505    
506            /**
507            * Returns a range of all the organizations that the user has permission to view where uuid = &#63; and companyId = &#63;.
508            *
509            * <p>
510            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
511            * </p>
512            *
513            * @param uuid the uuid
514            * @param companyId the company ID
515            * @param start the lower bound of the range of organizations
516            * @param end the upper bound of the range of organizations (not inclusive)
517            * @return the range of matching organizations that the user has permission to view
518            */
519            public static List<Organization> filterFindByUuid_C(java.lang.String uuid,
520                    long companyId, int start, int end) {
521                    return getPersistence().filterFindByUuid_C(uuid, companyId, start, end);
522            }
523    
524            /**
525            * Returns an ordered range of all the organizations that the user has permissions to view where uuid = &#63; and companyId = &#63;.
526            *
527            * <p>
528            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
529            * </p>
530            *
531            * @param uuid the uuid
532            * @param companyId the company ID
533            * @param start the lower bound of the range of organizations
534            * @param end the upper bound of the range of organizations (not inclusive)
535            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
536            * @return the ordered range of matching organizations that the user has permission to view
537            */
538            public static List<Organization> filterFindByUuid_C(java.lang.String uuid,
539                    long companyId, int start, int end,
540                    OrderByComparator<Organization> orderByComparator) {
541                    return getPersistence()
542                                       .filterFindByUuid_C(uuid, companyId, start, end,
543                            orderByComparator);
544            }
545    
546            /**
547            * Returns the organizations before and after the current organization in the ordered set of organizations that the user has permission to view where uuid = &#63; and companyId = &#63;.
548            *
549            * @param organizationId the primary key of the current organization
550            * @param uuid the uuid
551            * @param companyId the company ID
552            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
553            * @return the previous, current, and next organization
554            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
555            */
556            public static Organization[] filterFindByUuid_C_PrevAndNext(
557                    long organizationId, java.lang.String uuid, long companyId,
558                    OrderByComparator<Organization> orderByComparator)
559                    throws com.liferay.portal.exception.NoSuchOrganizationException {
560                    return getPersistence()
561                                       .filterFindByUuid_C_PrevAndNext(organizationId, uuid,
562                            companyId, orderByComparator);
563            }
564    
565            /**
566            * Removes all the organizations where uuid = &#63; and companyId = &#63; from the database.
567            *
568            * @param uuid the uuid
569            * @param companyId the company ID
570            */
571            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
572                    getPersistence().removeByUuid_C(uuid, companyId);
573            }
574    
575            /**
576            * Returns the number of organizations where uuid = &#63; and companyId = &#63;.
577            *
578            * @param uuid the uuid
579            * @param companyId the company ID
580            * @return the number of matching organizations
581            */
582            public static int countByUuid_C(java.lang.String uuid, long companyId) {
583                    return getPersistence().countByUuid_C(uuid, companyId);
584            }
585    
586            /**
587            * Returns the number of organizations that the user has permission to view where uuid = &#63; and companyId = &#63;.
588            *
589            * @param uuid the uuid
590            * @param companyId the company ID
591            * @return the number of matching organizations that the user has permission to view
592            */
593            public static int filterCountByUuid_C(java.lang.String uuid, long companyId) {
594                    return getPersistence().filterCountByUuid_C(uuid, companyId);
595            }
596    
597            /**
598            * Returns all the organizations where companyId = &#63;.
599            *
600            * @param companyId the company ID
601            * @return the matching organizations
602            */
603            public static List<Organization> findByCompanyId(long companyId) {
604                    return getPersistence().findByCompanyId(companyId);
605            }
606    
607            /**
608            * Returns a range of all the organizations where companyId = &#63;.
609            *
610            * <p>
611            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
612            * </p>
613            *
614            * @param companyId the company ID
615            * @param start the lower bound of the range of organizations
616            * @param end the upper bound of the range of organizations (not inclusive)
617            * @return the range of matching organizations
618            */
619            public static List<Organization> findByCompanyId(long companyId, int start,
620                    int end) {
621                    return getPersistence().findByCompanyId(companyId, start, end);
622            }
623    
624            /**
625            * Returns an ordered range of all the organizations where companyId = &#63;.
626            *
627            * <p>
628            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
629            * </p>
630            *
631            * @param companyId the company ID
632            * @param start the lower bound of the range of organizations
633            * @param end the upper bound of the range of organizations (not inclusive)
634            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
635            * @return the ordered range of matching organizations
636            */
637            public static List<Organization> findByCompanyId(long companyId, int start,
638                    int end, OrderByComparator<Organization> orderByComparator) {
639                    return getPersistence()
640                                       .findByCompanyId(companyId, start, end, orderByComparator);
641            }
642    
643            /**
644            * Returns an ordered range of all the organizations where companyId = &#63;.
645            *
646            * <p>
647            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
648            * </p>
649            *
650            * @param companyId the company ID
651            * @param start the lower bound of the range of organizations
652            * @param end the upper bound of the range of organizations (not inclusive)
653            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
654            * @param retrieveFromCache whether to retrieve from the finder cache
655            * @return the ordered range of matching organizations
656            */
657            public static List<Organization> findByCompanyId(long companyId, int start,
658                    int end, OrderByComparator<Organization> orderByComparator,
659                    boolean retrieveFromCache) {
660                    return getPersistence()
661                                       .findByCompanyId(companyId, start, end, orderByComparator,
662                            retrieveFromCache);
663            }
664    
665            /**
666            * Returns the first organization in the ordered set where companyId = &#63;.
667            *
668            * @param companyId the company ID
669            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
670            * @return the first matching organization
671            * @throws NoSuchOrganizationException if a matching organization could not be found
672            */
673            public static Organization findByCompanyId_First(long companyId,
674                    OrderByComparator<Organization> orderByComparator)
675                    throws com.liferay.portal.exception.NoSuchOrganizationException {
676                    return getPersistence()
677                                       .findByCompanyId_First(companyId, orderByComparator);
678            }
679    
680            /**
681            * Returns the first organization in the ordered set where companyId = &#63;.
682            *
683            * @param companyId the company ID
684            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
685            * @return the first matching organization, or <code>null</code> if a matching organization could not be found
686            */
687            public static Organization fetchByCompanyId_First(long companyId,
688                    OrderByComparator<Organization> orderByComparator) {
689                    return getPersistence()
690                                       .fetchByCompanyId_First(companyId, orderByComparator);
691            }
692    
693            /**
694            * Returns the last organization in the ordered set where companyId = &#63;.
695            *
696            * @param companyId the company ID
697            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
698            * @return the last matching organization
699            * @throws NoSuchOrganizationException if a matching organization could not be found
700            */
701            public static Organization findByCompanyId_Last(long companyId,
702                    OrderByComparator<Organization> orderByComparator)
703                    throws com.liferay.portal.exception.NoSuchOrganizationException {
704                    return getPersistence()
705                                       .findByCompanyId_Last(companyId, orderByComparator);
706            }
707    
708            /**
709            * Returns the last organization in the ordered set where companyId = &#63;.
710            *
711            * @param companyId the company ID
712            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
713            * @return the last matching organization, or <code>null</code> if a matching organization could not be found
714            */
715            public static Organization fetchByCompanyId_Last(long companyId,
716                    OrderByComparator<Organization> orderByComparator) {
717                    return getPersistence()
718                                       .fetchByCompanyId_Last(companyId, orderByComparator);
719            }
720    
721            /**
722            * Returns the organizations before and after the current organization in the ordered set where companyId = &#63;.
723            *
724            * @param organizationId the primary key of the current organization
725            * @param companyId the company ID
726            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
727            * @return the previous, current, and next organization
728            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
729            */
730            public static Organization[] findByCompanyId_PrevAndNext(
731                    long organizationId, long companyId,
732                    OrderByComparator<Organization> orderByComparator)
733                    throws com.liferay.portal.exception.NoSuchOrganizationException {
734                    return getPersistence()
735                                       .findByCompanyId_PrevAndNext(organizationId, companyId,
736                            orderByComparator);
737            }
738    
739            /**
740            * Returns all the organizations that the user has permission to view where companyId = &#63;.
741            *
742            * @param companyId the company ID
743            * @return the matching organizations that the user has permission to view
744            */
745            public static List<Organization> filterFindByCompanyId(long companyId) {
746                    return getPersistence().filterFindByCompanyId(companyId);
747            }
748    
749            /**
750            * Returns a range of all the organizations that the user has permission to view where companyId = &#63;.
751            *
752            * <p>
753            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
754            * </p>
755            *
756            * @param companyId the company ID
757            * @param start the lower bound of the range of organizations
758            * @param end the upper bound of the range of organizations (not inclusive)
759            * @return the range of matching organizations that the user has permission to view
760            */
761            public static List<Organization> filterFindByCompanyId(long companyId,
762                    int start, int end) {
763                    return getPersistence().filterFindByCompanyId(companyId, start, end);
764            }
765    
766            /**
767            * Returns an ordered range of all the organizations that the user has permissions to view where companyId = &#63;.
768            *
769            * <p>
770            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
771            * </p>
772            *
773            * @param companyId the company ID
774            * @param start the lower bound of the range of organizations
775            * @param end the upper bound of the range of organizations (not inclusive)
776            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
777            * @return the ordered range of matching organizations that the user has permission to view
778            */
779            public static List<Organization> filterFindByCompanyId(long companyId,
780                    int start, int end, OrderByComparator<Organization> orderByComparator) {
781                    return getPersistence()
782                                       .filterFindByCompanyId(companyId, start, end,
783                            orderByComparator);
784            }
785    
786            /**
787            * Returns the organizations before and after the current organization in the ordered set of organizations that the user has permission to view where companyId = &#63;.
788            *
789            * @param organizationId the primary key of the current organization
790            * @param companyId the company ID
791            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
792            * @return the previous, current, and next organization
793            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
794            */
795            public static Organization[] filterFindByCompanyId_PrevAndNext(
796                    long organizationId, long companyId,
797                    OrderByComparator<Organization> orderByComparator)
798                    throws com.liferay.portal.exception.NoSuchOrganizationException {
799                    return getPersistence()
800                                       .filterFindByCompanyId_PrevAndNext(organizationId,
801                            companyId, orderByComparator);
802            }
803    
804            /**
805            * Removes all the organizations where companyId = &#63; from the database.
806            *
807            * @param companyId the company ID
808            */
809            public static void removeByCompanyId(long companyId) {
810                    getPersistence().removeByCompanyId(companyId);
811            }
812    
813            /**
814            * Returns the number of organizations where companyId = &#63;.
815            *
816            * @param companyId the company ID
817            * @return the number of matching organizations
818            */
819            public static int countByCompanyId(long companyId) {
820                    return getPersistence().countByCompanyId(companyId);
821            }
822    
823            /**
824            * Returns the number of organizations that the user has permission to view where companyId = &#63;.
825            *
826            * @param companyId the company ID
827            * @return the number of matching organizations that the user has permission to view
828            */
829            public static int filterCountByCompanyId(long companyId) {
830                    return getPersistence().filterCountByCompanyId(companyId);
831            }
832    
833            /**
834            * Returns all the organizations where companyId = &#63;.
835            *
836            * @param companyId the company ID
837            * @return the matching organizations
838            */
839            public static List<Organization> findByLocations(long companyId) {
840                    return getPersistence().findByLocations(companyId);
841            }
842    
843            /**
844            * Returns a range of all the organizations where companyId = &#63;.
845            *
846            * <p>
847            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
848            * </p>
849            *
850            * @param companyId the company ID
851            * @param start the lower bound of the range of organizations
852            * @param end the upper bound of the range of organizations (not inclusive)
853            * @return the range of matching organizations
854            */
855            public static List<Organization> findByLocations(long companyId, int start,
856                    int end) {
857                    return getPersistence().findByLocations(companyId, start, end);
858            }
859    
860            /**
861            * Returns an ordered range of all the organizations where companyId = &#63;.
862            *
863            * <p>
864            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
865            * </p>
866            *
867            * @param companyId the company ID
868            * @param start the lower bound of the range of organizations
869            * @param end the upper bound of the range of organizations (not inclusive)
870            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
871            * @return the ordered range of matching organizations
872            */
873            public static List<Organization> findByLocations(long companyId, int start,
874                    int end, OrderByComparator<Organization> orderByComparator) {
875                    return getPersistence()
876                                       .findByLocations(companyId, start, end, orderByComparator);
877            }
878    
879            /**
880            * Returns an ordered range of all the organizations where companyId = &#63;.
881            *
882            * <p>
883            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
884            * </p>
885            *
886            * @param companyId the company ID
887            * @param start the lower bound of the range of organizations
888            * @param end the upper bound of the range of organizations (not inclusive)
889            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
890            * @param retrieveFromCache whether to retrieve from the finder cache
891            * @return the ordered range of matching organizations
892            */
893            public static List<Organization> findByLocations(long companyId, int start,
894                    int end, OrderByComparator<Organization> orderByComparator,
895                    boolean retrieveFromCache) {
896                    return getPersistence()
897                                       .findByLocations(companyId, start, end, orderByComparator,
898                            retrieveFromCache);
899            }
900    
901            /**
902            * Returns the first organization in the ordered set where companyId = &#63;.
903            *
904            * @param companyId the company ID
905            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
906            * @return the first matching organization
907            * @throws NoSuchOrganizationException if a matching organization could not be found
908            */
909            public static Organization findByLocations_First(long companyId,
910                    OrderByComparator<Organization> orderByComparator)
911                    throws com.liferay.portal.exception.NoSuchOrganizationException {
912                    return getPersistence()
913                                       .findByLocations_First(companyId, orderByComparator);
914            }
915    
916            /**
917            * Returns the first organization in the ordered set where companyId = &#63;.
918            *
919            * @param companyId the company ID
920            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
921            * @return the first matching organization, or <code>null</code> if a matching organization could not be found
922            */
923            public static Organization fetchByLocations_First(long companyId,
924                    OrderByComparator<Organization> orderByComparator) {
925                    return getPersistence()
926                                       .fetchByLocations_First(companyId, orderByComparator);
927            }
928    
929            /**
930            * Returns the last organization in the ordered set where companyId = &#63;.
931            *
932            * @param companyId the company ID
933            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
934            * @return the last matching organization
935            * @throws NoSuchOrganizationException if a matching organization could not be found
936            */
937            public static Organization findByLocations_Last(long companyId,
938                    OrderByComparator<Organization> orderByComparator)
939                    throws com.liferay.portal.exception.NoSuchOrganizationException {
940                    return getPersistence()
941                                       .findByLocations_Last(companyId, orderByComparator);
942            }
943    
944            /**
945            * Returns the last organization in the ordered set where companyId = &#63;.
946            *
947            * @param companyId the company ID
948            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
949            * @return the last matching organization, or <code>null</code> if a matching organization could not be found
950            */
951            public static Organization fetchByLocations_Last(long companyId,
952                    OrderByComparator<Organization> orderByComparator) {
953                    return getPersistence()
954                                       .fetchByLocations_Last(companyId, orderByComparator);
955            }
956    
957            /**
958            * Returns the organizations before and after the current organization in the ordered set where companyId = &#63;.
959            *
960            * @param organizationId the primary key of the current organization
961            * @param companyId the company ID
962            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
963            * @return the previous, current, and next organization
964            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
965            */
966            public static Organization[] findByLocations_PrevAndNext(
967                    long organizationId, long companyId,
968                    OrderByComparator<Organization> orderByComparator)
969                    throws com.liferay.portal.exception.NoSuchOrganizationException {
970                    return getPersistence()
971                                       .findByLocations_PrevAndNext(organizationId, companyId,
972                            orderByComparator);
973            }
974    
975            /**
976            * Returns all the organizations that the user has permission to view where companyId = &#63;.
977            *
978            * @param companyId the company ID
979            * @return the matching organizations that the user has permission to view
980            */
981            public static List<Organization> filterFindByLocations(long companyId) {
982                    return getPersistence().filterFindByLocations(companyId);
983            }
984    
985            /**
986            * Returns a range of all the organizations that the user has permission to view where companyId = &#63;.
987            *
988            * <p>
989            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
990            * </p>
991            *
992            * @param companyId the company ID
993            * @param start the lower bound of the range of organizations
994            * @param end the upper bound of the range of organizations (not inclusive)
995            * @return the range of matching organizations that the user has permission to view
996            */
997            public static List<Organization> filterFindByLocations(long companyId,
998                    int start, int end) {
999                    return getPersistence().filterFindByLocations(companyId, start, end);
1000            }
1001    
1002            /**
1003            * Returns an ordered range of all the organizations that the user has permissions to view where companyId = &#63;.
1004            *
1005            * <p>
1006            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1007            * </p>
1008            *
1009            * @param companyId the company ID
1010            * @param start the lower bound of the range of organizations
1011            * @param end the upper bound of the range of organizations (not inclusive)
1012            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1013            * @return the ordered range of matching organizations that the user has permission to view
1014            */
1015            public static List<Organization> filterFindByLocations(long companyId,
1016                    int start, int end, OrderByComparator<Organization> orderByComparator) {
1017                    return getPersistence()
1018                                       .filterFindByLocations(companyId, start, end,
1019                            orderByComparator);
1020            }
1021    
1022            /**
1023            * Returns the organizations before and after the current organization in the ordered set of organizations that the user has permission to view where companyId = &#63;.
1024            *
1025            * @param organizationId the primary key of the current organization
1026            * @param companyId the company ID
1027            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1028            * @return the previous, current, and next organization
1029            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
1030            */
1031            public static Organization[] filterFindByLocations_PrevAndNext(
1032                    long organizationId, long companyId,
1033                    OrderByComparator<Organization> orderByComparator)
1034                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1035                    return getPersistence()
1036                                       .filterFindByLocations_PrevAndNext(organizationId,
1037                            companyId, orderByComparator);
1038            }
1039    
1040            /**
1041            * Removes all the organizations where companyId = &#63; from the database.
1042            *
1043            * @param companyId the company ID
1044            */
1045            public static void removeByLocations(long companyId) {
1046                    getPersistence().removeByLocations(companyId);
1047            }
1048    
1049            /**
1050            * Returns the number of organizations where companyId = &#63;.
1051            *
1052            * @param companyId the company ID
1053            * @return the number of matching organizations
1054            */
1055            public static int countByLocations(long companyId) {
1056                    return getPersistence().countByLocations(companyId);
1057            }
1058    
1059            /**
1060            * Returns the number of organizations that the user has permission to view where companyId = &#63;.
1061            *
1062            * @param companyId the company ID
1063            * @return the number of matching organizations that the user has permission to view
1064            */
1065            public static int filterCountByLocations(long companyId) {
1066                    return getPersistence().filterCountByLocations(companyId);
1067            }
1068    
1069            /**
1070            * Returns all the organizations where companyId = &#63; and parentOrganizationId = &#63;.
1071            *
1072            * @param companyId the company ID
1073            * @param parentOrganizationId the parent organization ID
1074            * @return the matching organizations
1075            */
1076            public static List<Organization> findByC_P(long companyId,
1077                    long parentOrganizationId) {
1078                    return getPersistence().findByC_P(companyId, parentOrganizationId);
1079            }
1080    
1081            /**
1082            * Returns a range of all the organizations where companyId = &#63; and parentOrganizationId = &#63;.
1083            *
1084            * <p>
1085            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1086            * </p>
1087            *
1088            * @param companyId the company ID
1089            * @param parentOrganizationId the parent organization ID
1090            * @param start the lower bound of the range of organizations
1091            * @param end the upper bound of the range of organizations (not inclusive)
1092            * @return the range of matching organizations
1093            */
1094            public static List<Organization> findByC_P(long companyId,
1095                    long parentOrganizationId, int start, int end) {
1096                    return getPersistence()
1097                                       .findByC_P(companyId, parentOrganizationId, start, end);
1098            }
1099    
1100            /**
1101            * Returns an ordered range of all the organizations where companyId = &#63; and parentOrganizationId = &#63;.
1102            *
1103            * <p>
1104            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1105            * </p>
1106            *
1107            * @param companyId the company ID
1108            * @param parentOrganizationId the parent organization ID
1109            * @param start the lower bound of the range of organizations
1110            * @param end the upper bound of the range of organizations (not inclusive)
1111            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1112            * @return the ordered range of matching organizations
1113            */
1114            public static List<Organization> findByC_P(long companyId,
1115                    long parentOrganizationId, int start, int end,
1116                    OrderByComparator<Organization> orderByComparator) {
1117                    return getPersistence()
1118                                       .findByC_P(companyId, parentOrganizationId, start, end,
1119                            orderByComparator);
1120            }
1121    
1122            /**
1123            * Returns an ordered range of all the organizations where companyId = &#63; and parentOrganizationId = &#63;.
1124            *
1125            * <p>
1126            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1127            * </p>
1128            *
1129            * @param companyId the company ID
1130            * @param parentOrganizationId the parent organization ID
1131            * @param start the lower bound of the range of organizations
1132            * @param end the upper bound of the range of organizations (not inclusive)
1133            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1134            * @param retrieveFromCache whether to retrieve from the finder cache
1135            * @return the ordered range of matching organizations
1136            */
1137            public static List<Organization> findByC_P(long companyId,
1138                    long parentOrganizationId, int start, int end,
1139                    OrderByComparator<Organization> orderByComparator,
1140                    boolean retrieveFromCache) {
1141                    return getPersistence()
1142                                       .findByC_P(companyId, parentOrganizationId, start, end,
1143                            orderByComparator, retrieveFromCache);
1144            }
1145    
1146            /**
1147            * Returns the first organization in the ordered set where companyId = &#63; and parentOrganizationId = &#63;.
1148            *
1149            * @param companyId the company ID
1150            * @param parentOrganizationId the parent organization ID
1151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1152            * @return the first matching organization
1153            * @throws NoSuchOrganizationException if a matching organization could not be found
1154            */
1155            public static Organization findByC_P_First(long companyId,
1156                    long parentOrganizationId,
1157                    OrderByComparator<Organization> orderByComparator)
1158                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1159                    return getPersistence()
1160                                       .findByC_P_First(companyId, parentOrganizationId,
1161                            orderByComparator);
1162            }
1163    
1164            /**
1165            * Returns the first organization in the ordered set where companyId = &#63; and parentOrganizationId = &#63;.
1166            *
1167            * @param companyId the company ID
1168            * @param parentOrganizationId the parent organization ID
1169            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1170            * @return the first matching organization, or <code>null</code> if a matching organization could not be found
1171            */
1172            public static Organization fetchByC_P_First(long companyId,
1173                    long parentOrganizationId,
1174                    OrderByComparator<Organization> orderByComparator) {
1175                    return getPersistence()
1176                                       .fetchByC_P_First(companyId, parentOrganizationId,
1177                            orderByComparator);
1178            }
1179    
1180            /**
1181            * Returns the last organization in the ordered set where companyId = &#63; and parentOrganizationId = &#63;.
1182            *
1183            * @param companyId the company ID
1184            * @param parentOrganizationId the parent organization ID
1185            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1186            * @return the last matching organization
1187            * @throws NoSuchOrganizationException if a matching organization could not be found
1188            */
1189            public static Organization findByC_P_Last(long companyId,
1190                    long parentOrganizationId,
1191                    OrderByComparator<Organization> orderByComparator)
1192                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1193                    return getPersistence()
1194                                       .findByC_P_Last(companyId, parentOrganizationId,
1195                            orderByComparator);
1196            }
1197    
1198            /**
1199            * Returns the last organization in the ordered set where companyId = &#63; and parentOrganizationId = &#63;.
1200            *
1201            * @param companyId the company ID
1202            * @param parentOrganizationId the parent organization ID
1203            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1204            * @return the last matching organization, or <code>null</code> if a matching organization could not be found
1205            */
1206            public static Organization fetchByC_P_Last(long companyId,
1207                    long parentOrganizationId,
1208                    OrderByComparator<Organization> orderByComparator) {
1209                    return getPersistence()
1210                                       .fetchByC_P_Last(companyId, parentOrganizationId,
1211                            orderByComparator);
1212            }
1213    
1214            /**
1215            * Returns the organizations before and after the current organization in the ordered set where companyId = &#63; and parentOrganizationId = &#63;.
1216            *
1217            * @param organizationId the primary key of the current organization
1218            * @param companyId the company ID
1219            * @param parentOrganizationId the parent organization ID
1220            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1221            * @return the previous, current, and next organization
1222            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
1223            */
1224            public static Organization[] findByC_P_PrevAndNext(long organizationId,
1225                    long companyId, long parentOrganizationId,
1226                    OrderByComparator<Organization> orderByComparator)
1227                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1228                    return getPersistence()
1229                                       .findByC_P_PrevAndNext(organizationId, companyId,
1230                            parentOrganizationId, orderByComparator);
1231            }
1232    
1233            /**
1234            * Returns all the organizations that the user has permission to view where companyId = &#63; and parentOrganizationId = &#63;.
1235            *
1236            * @param companyId the company ID
1237            * @param parentOrganizationId the parent organization ID
1238            * @return the matching organizations that the user has permission to view
1239            */
1240            public static List<Organization> filterFindByC_P(long companyId,
1241                    long parentOrganizationId) {
1242                    return getPersistence().filterFindByC_P(companyId, parentOrganizationId);
1243            }
1244    
1245            /**
1246            * Returns a range of all the organizations that the user has permission to view where companyId = &#63; and parentOrganizationId = &#63;.
1247            *
1248            * <p>
1249            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1250            * </p>
1251            *
1252            * @param companyId the company ID
1253            * @param parentOrganizationId the parent organization ID
1254            * @param start the lower bound of the range of organizations
1255            * @param end the upper bound of the range of organizations (not inclusive)
1256            * @return the range of matching organizations that the user has permission to view
1257            */
1258            public static List<Organization> filterFindByC_P(long companyId,
1259                    long parentOrganizationId, int start, int end) {
1260                    return getPersistence()
1261                                       .filterFindByC_P(companyId, parentOrganizationId, start, end);
1262            }
1263    
1264            /**
1265            * Returns an ordered range of all the organizations that the user has permissions to view where companyId = &#63; and parentOrganizationId = &#63;.
1266            *
1267            * <p>
1268            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1269            * </p>
1270            *
1271            * @param companyId the company ID
1272            * @param parentOrganizationId the parent organization ID
1273            * @param start the lower bound of the range of organizations
1274            * @param end the upper bound of the range of organizations (not inclusive)
1275            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1276            * @return the ordered range of matching organizations that the user has permission to view
1277            */
1278            public static List<Organization> filterFindByC_P(long companyId,
1279                    long parentOrganizationId, int start, int end,
1280                    OrderByComparator<Organization> orderByComparator) {
1281                    return getPersistence()
1282                                       .filterFindByC_P(companyId, parentOrganizationId, start,
1283                            end, orderByComparator);
1284            }
1285    
1286            /**
1287            * Returns the organizations before and after the current organization in the ordered set of organizations that the user has permission to view where companyId = &#63; and parentOrganizationId = &#63;.
1288            *
1289            * @param organizationId the primary key of the current organization
1290            * @param companyId the company ID
1291            * @param parentOrganizationId the parent organization ID
1292            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1293            * @return the previous, current, and next organization
1294            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
1295            */
1296            public static Organization[] filterFindByC_P_PrevAndNext(
1297                    long organizationId, long companyId, long parentOrganizationId,
1298                    OrderByComparator<Organization> orderByComparator)
1299                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1300                    return getPersistence()
1301                                       .filterFindByC_P_PrevAndNext(organizationId, companyId,
1302                            parentOrganizationId, orderByComparator);
1303            }
1304    
1305            /**
1306            * Removes all the organizations where companyId = &#63; and parentOrganizationId = &#63; from the database.
1307            *
1308            * @param companyId the company ID
1309            * @param parentOrganizationId the parent organization ID
1310            */
1311            public static void removeByC_P(long companyId, long parentOrganizationId) {
1312                    getPersistence().removeByC_P(companyId, parentOrganizationId);
1313            }
1314    
1315            /**
1316            * Returns the number of organizations where companyId = &#63; and parentOrganizationId = &#63;.
1317            *
1318            * @param companyId the company ID
1319            * @param parentOrganizationId the parent organization ID
1320            * @return the number of matching organizations
1321            */
1322            public static int countByC_P(long companyId, long parentOrganizationId) {
1323                    return getPersistence().countByC_P(companyId, parentOrganizationId);
1324            }
1325    
1326            /**
1327            * Returns the number of organizations that the user has permission to view where companyId = &#63; and parentOrganizationId = &#63;.
1328            *
1329            * @param companyId the company ID
1330            * @param parentOrganizationId the parent organization ID
1331            * @return the number of matching organizations that the user has permission to view
1332            */
1333            public static int filterCountByC_P(long companyId, long parentOrganizationId) {
1334                    return getPersistence().filterCountByC_P(companyId, parentOrganizationId);
1335            }
1336    
1337            /**
1338            * Returns all the organizations where companyId = &#63; and treePath LIKE &#63;.
1339            *
1340            * @param companyId the company ID
1341            * @param treePath the tree path
1342            * @return the matching organizations
1343            */
1344            public static List<Organization> findByC_T(long companyId,
1345                    java.lang.String treePath) {
1346                    return getPersistence().findByC_T(companyId, treePath);
1347            }
1348    
1349            /**
1350            * Returns a range of all the organizations where companyId = &#63; and treePath LIKE &#63;.
1351            *
1352            * <p>
1353            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1354            * </p>
1355            *
1356            * @param companyId the company ID
1357            * @param treePath the tree path
1358            * @param start the lower bound of the range of organizations
1359            * @param end the upper bound of the range of organizations (not inclusive)
1360            * @return the range of matching organizations
1361            */
1362            public static List<Organization> findByC_T(long companyId,
1363                    java.lang.String treePath, int start, int end) {
1364                    return getPersistence().findByC_T(companyId, treePath, start, end);
1365            }
1366    
1367            /**
1368            * Returns an ordered range of all the organizations where companyId = &#63; and treePath LIKE &#63;.
1369            *
1370            * <p>
1371            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1372            * </p>
1373            *
1374            * @param companyId the company ID
1375            * @param treePath the tree path
1376            * @param start the lower bound of the range of organizations
1377            * @param end the upper bound of the range of organizations (not inclusive)
1378            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1379            * @return the ordered range of matching organizations
1380            */
1381            public static List<Organization> findByC_T(long companyId,
1382                    java.lang.String treePath, int start, int end,
1383                    OrderByComparator<Organization> orderByComparator) {
1384                    return getPersistence()
1385                                       .findByC_T(companyId, treePath, start, end, orderByComparator);
1386            }
1387    
1388            /**
1389            * Returns an ordered range of all the organizations where companyId = &#63; and treePath LIKE &#63;.
1390            *
1391            * <p>
1392            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1393            * </p>
1394            *
1395            * @param companyId the company ID
1396            * @param treePath the tree path
1397            * @param start the lower bound of the range of organizations
1398            * @param end the upper bound of the range of organizations (not inclusive)
1399            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1400            * @param retrieveFromCache whether to retrieve from the finder cache
1401            * @return the ordered range of matching organizations
1402            */
1403            public static List<Organization> findByC_T(long companyId,
1404                    java.lang.String treePath, int start, int end,
1405                    OrderByComparator<Organization> orderByComparator,
1406                    boolean retrieveFromCache) {
1407                    return getPersistence()
1408                                       .findByC_T(companyId, treePath, start, end,
1409                            orderByComparator, retrieveFromCache);
1410            }
1411    
1412            /**
1413            * Returns the first organization in the ordered set where companyId = &#63; and treePath LIKE &#63;.
1414            *
1415            * @param companyId the company ID
1416            * @param treePath the tree path
1417            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1418            * @return the first matching organization
1419            * @throws NoSuchOrganizationException if a matching organization could not be found
1420            */
1421            public static Organization findByC_T_First(long companyId,
1422                    java.lang.String treePath,
1423                    OrderByComparator<Organization> orderByComparator)
1424                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1425                    return getPersistence()
1426                                       .findByC_T_First(companyId, treePath, orderByComparator);
1427            }
1428    
1429            /**
1430            * Returns the first organization in the ordered set where companyId = &#63; and treePath LIKE &#63;.
1431            *
1432            * @param companyId the company ID
1433            * @param treePath the tree path
1434            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1435            * @return the first matching organization, or <code>null</code> if a matching organization could not be found
1436            */
1437            public static Organization fetchByC_T_First(long companyId,
1438                    java.lang.String treePath,
1439                    OrderByComparator<Organization> orderByComparator) {
1440                    return getPersistence()
1441                                       .fetchByC_T_First(companyId, treePath, orderByComparator);
1442            }
1443    
1444            /**
1445            * Returns the last organization in the ordered set where companyId = &#63; and treePath LIKE &#63;.
1446            *
1447            * @param companyId the company ID
1448            * @param treePath the tree path
1449            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1450            * @return the last matching organization
1451            * @throws NoSuchOrganizationException if a matching organization could not be found
1452            */
1453            public static Organization findByC_T_Last(long companyId,
1454                    java.lang.String treePath,
1455                    OrderByComparator<Organization> orderByComparator)
1456                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1457                    return getPersistence()
1458                                       .findByC_T_Last(companyId, treePath, orderByComparator);
1459            }
1460    
1461            /**
1462            * Returns the last organization in the ordered set where companyId = &#63; and treePath LIKE &#63;.
1463            *
1464            * @param companyId the company ID
1465            * @param treePath the tree path
1466            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1467            * @return the last matching organization, or <code>null</code> if a matching organization could not be found
1468            */
1469            public static Organization fetchByC_T_Last(long companyId,
1470                    java.lang.String treePath,
1471                    OrderByComparator<Organization> orderByComparator) {
1472                    return getPersistence()
1473                                       .fetchByC_T_Last(companyId, treePath, orderByComparator);
1474            }
1475    
1476            /**
1477            * Returns the organizations before and after the current organization in the ordered set where companyId = &#63; and treePath LIKE &#63;.
1478            *
1479            * @param organizationId the primary key of the current organization
1480            * @param companyId the company ID
1481            * @param treePath the tree path
1482            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1483            * @return the previous, current, and next organization
1484            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
1485            */
1486            public static Organization[] findByC_T_PrevAndNext(long organizationId,
1487                    long companyId, java.lang.String treePath,
1488                    OrderByComparator<Organization> orderByComparator)
1489                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1490                    return getPersistence()
1491                                       .findByC_T_PrevAndNext(organizationId, companyId, treePath,
1492                            orderByComparator);
1493            }
1494    
1495            /**
1496            * Returns all the organizations that the user has permission to view where companyId = &#63; and treePath LIKE &#63;.
1497            *
1498            * @param companyId the company ID
1499            * @param treePath the tree path
1500            * @return the matching organizations that the user has permission to view
1501            */
1502            public static List<Organization> filterFindByC_T(long companyId,
1503                    java.lang.String treePath) {
1504                    return getPersistence().filterFindByC_T(companyId, treePath);
1505            }
1506    
1507            /**
1508            * Returns a range of all the organizations that the user has permission to view where companyId = &#63; and treePath LIKE &#63;.
1509            *
1510            * <p>
1511            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1512            * </p>
1513            *
1514            * @param companyId the company ID
1515            * @param treePath the tree path
1516            * @param start the lower bound of the range of organizations
1517            * @param end the upper bound of the range of organizations (not inclusive)
1518            * @return the range of matching organizations that the user has permission to view
1519            */
1520            public static List<Organization> filterFindByC_T(long companyId,
1521                    java.lang.String treePath, int start, int end) {
1522                    return getPersistence().filterFindByC_T(companyId, treePath, start, end);
1523            }
1524    
1525            /**
1526            * Returns an ordered range of all the organizations that the user has permissions to view where companyId = &#63; and treePath LIKE &#63;.
1527            *
1528            * <p>
1529            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1530            * </p>
1531            *
1532            * @param companyId the company ID
1533            * @param treePath the tree path
1534            * @param start the lower bound of the range of organizations
1535            * @param end the upper bound of the range of organizations (not inclusive)
1536            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1537            * @return the ordered range of matching organizations that the user has permission to view
1538            */
1539            public static List<Organization> filterFindByC_T(long companyId,
1540                    java.lang.String treePath, int start, int end,
1541                    OrderByComparator<Organization> orderByComparator) {
1542                    return getPersistence()
1543                                       .filterFindByC_T(companyId, treePath, start, end,
1544                            orderByComparator);
1545            }
1546    
1547            /**
1548            * Returns the organizations before and after the current organization in the ordered set of organizations that the user has permission to view where companyId = &#63; and treePath LIKE &#63;.
1549            *
1550            * @param organizationId the primary key of the current organization
1551            * @param companyId the company ID
1552            * @param treePath the tree path
1553            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1554            * @return the previous, current, and next organization
1555            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
1556            */
1557            public static Organization[] filterFindByC_T_PrevAndNext(
1558                    long organizationId, long companyId, java.lang.String treePath,
1559                    OrderByComparator<Organization> orderByComparator)
1560                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1561                    return getPersistence()
1562                                       .filterFindByC_T_PrevAndNext(organizationId, companyId,
1563                            treePath, orderByComparator);
1564            }
1565    
1566            /**
1567            * Removes all the organizations where companyId = &#63; and treePath LIKE &#63; from the database.
1568            *
1569            * @param companyId the company ID
1570            * @param treePath the tree path
1571            */
1572            public static void removeByC_T(long companyId, java.lang.String treePath) {
1573                    getPersistence().removeByC_T(companyId, treePath);
1574            }
1575    
1576            /**
1577            * Returns the number of organizations where companyId = &#63; and treePath LIKE &#63;.
1578            *
1579            * @param companyId the company ID
1580            * @param treePath the tree path
1581            * @return the number of matching organizations
1582            */
1583            public static int countByC_T(long companyId, java.lang.String treePath) {
1584                    return getPersistence().countByC_T(companyId, treePath);
1585            }
1586    
1587            /**
1588            * Returns the number of organizations that the user has permission to view where companyId = &#63; and treePath LIKE &#63;.
1589            *
1590            * @param companyId the company ID
1591            * @param treePath the tree path
1592            * @return the number of matching organizations that the user has permission to view
1593            */
1594            public static int filterCountByC_T(long companyId, java.lang.String treePath) {
1595                    return getPersistence().filterCountByC_T(companyId, treePath);
1596            }
1597    
1598            /**
1599            * Returns the organization where companyId = &#63; and name = &#63; or throws a {@link NoSuchOrganizationException} if it could not be found.
1600            *
1601            * @param companyId the company ID
1602            * @param name the name
1603            * @return the matching organization
1604            * @throws NoSuchOrganizationException if a matching organization could not be found
1605            */
1606            public static Organization findByC_N(long companyId, java.lang.String name)
1607                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1608                    return getPersistence().findByC_N(companyId, name);
1609            }
1610    
1611            /**
1612            * Returns the organization where companyId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1613            *
1614            * @param companyId the company ID
1615            * @param name the name
1616            * @return the matching organization, or <code>null</code> if a matching organization could not be found
1617            */
1618            public static Organization fetchByC_N(long companyId, java.lang.String name) {
1619                    return getPersistence().fetchByC_N(companyId, name);
1620            }
1621    
1622            /**
1623            * Returns the organization where companyId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1624            *
1625            * @param companyId the company ID
1626            * @param name the name
1627            * @param retrieveFromCache whether to retrieve from the finder cache
1628            * @return the matching organization, or <code>null</code> if a matching organization could not be found
1629            */
1630            public static Organization fetchByC_N(long companyId,
1631                    java.lang.String name, boolean retrieveFromCache) {
1632                    return getPersistence().fetchByC_N(companyId, name, retrieveFromCache);
1633            }
1634    
1635            /**
1636            * Removes the organization where companyId = &#63; and name = &#63; from the database.
1637            *
1638            * @param companyId the company ID
1639            * @param name the name
1640            * @return the organization that was removed
1641            */
1642            public static Organization removeByC_N(long companyId, java.lang.String name)
1643                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1644                    return getPersistence().removeByC_N(companyId, name);
1645            }
1646    
1647            /**
1648            * Returns the number of organizations where companyId = &#63; and name = &#63;.
1649            *
1650            * @param companyId the company ID
1651            * @param name the name
1652            * @return the number of matching organizations
1653            */
1654            public static int countByC_N(long companyId, java.lang.String name) {
1655                    return getPersistence().countByC_N(companyId, name);
1656            }
1657    
1658            /**
1659            * Returns all the organizations where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1660            *
1661            * @param organizationId the organization ID
1662            * @param companyId the company ID
1663            * @param parentOrganizationId the parent organization ID
1664            * @return the matching organizations
1665            */
1666            public static List<Organization> findByO_C_P(long organizationId,
1667                    long companyId, long parentOrganizationId) {
1668                    return getPersistence()
1669                                       .findByO_C_P(organizationId, companyId, parentOrganizationId);
1670            }
1671    
1672            /**
1673            * Returns a range of all the organizations where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1674            *
1675            * <p>
1676            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1677            * </p>
1678            *
1679            * @param organizationId the organization ID
1680            * @param companyId the company ID
1681            * @param parentOrganizationId the parent organization ID
1682            * @param start the lower bound of the range of organizations
1683            * @param end the upper bound of the range of organizations (not inclusive)
1684            * @return the range of matching organizations
1685            */
1686            public static List<Organization> findByO_C_P(long organizationId,
1687                    long companyId, long parentOrganizationId, int start, int end) {
1688                    return getPersistence()
1689                                       .findByO_C_P(organizationId, companyId,
1690                            parentOrganizationId, start, end);
1691            }
1692    
1693            /**
1694            * Returns an ordered range of all the organizations where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1695            *
1696            * <p>
1697            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1698            * </p>
1699            *
1700            * @param organizationId the organization ID
1701            * @param companyId the company ID
1702            * @param parentOrganizationId the parent organization ID
1703            * @param start the lower bound of the range of organizations
1704            * @param end the upper bound of the range of organizations (not inclusive)
1705            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1706            * @return the ordered range of matching organizations
1707            */
1708            public static List<Organization> findByO_C_P(long organizationId,
1709                    long companyId, long parentOrganizationId, int start, int end,
1710                    OrderByComparator<Organization> orderByComparator) {
1711                    return getPersistence()
1712                                       .findByO_C_P(organizationId, companyId,
1713                            parentOrganizationId, start, end, orderByComparator);
1714            }
1715    
1716            /**
1717            * Returns an ordered range of all the organizations where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1718            *
1719            * <p>
1720            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1721            * </p>
1722            *
1723            * @param organizationId the organization ID
1724            * @param companyId the company ID
1725            * @param parentOrganizationId the parent organization ID
1726            * @param start the lower bound of the range of organizations
1727            * @param end the upper bound of the range of organizations (not inclusive)
1728            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1729            * @param retrieveFromCache whether to retrieve from the finder cache
1730            * @return the ordered range of matching organizations
1731            */
1732            public static List<Organization> findByO_C_P(long organizationId,
1733                    long companyId, long parentOrganizationId, int start, int end,
1734                    OrderByComparator<Organization> orderByComparator,
1735                    boolean retrieveFromCache) {
1736                    return getPersistence()
1737                                       .findByO_C_P(organizationId, companyId,
1738                            parentOrganizationId, start, end, orderByComparator,
1739                            retrieveFromCache);
1740            }
1741    
1742            /**
1743            * Returns the first organization in the ordered set where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1744            *
1745            * @param organizationId the organization ID
1746            * @param companyId the company ID
1747            * @param parentOrganizationId the parent organization ID
1748            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1749            * @return the first matching organization
1750            * @throws NoSuchOrganizationException if a matching organization could not be found
1751            */
1752            public static Organization findByO_C_P_First(long organizationId,
1753                    long companyId, long parentOrganizationId,
1754                    OrderByComparator<Organization> orderByComparator)
1755                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1756                    return getPersistence()
1757                                       .findByO_C_P_First(organizationId, companyId,
1758                            parentOrganizationId, orderByComparator);
1759            }
1760    
1761            /**
1762            * Returns the first organization in the ordered set where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1763            *
1764            * @param organizationId the organization ID
1765            * @param companyId the company ID
1766            * @param parentOrganizationId the parent organization ID
1767            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1768            * @return the first matching organization, or <code>null</code> if a matching organization could not be found
1769            */
1770            public static Organization fetchByO_C_P_First(long organizationId,
1771                    long companyId, long parentOrganizationId,
1772                    OrderByComparator<Organization> orderByComparator) {
1773                    return getPersistence()
1774                                       .fetchByO_C_P_First(organizationId, companyId,
1775                            parentOrganizationId, orderByComparator);
1776            }
1777    
1778            /**
1779            * Returns the last organization in the ordered set where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1780            *
1781            * @param organizationId the organization ID
1782            * @param companyId the company ID
1783            * @param parentOrganizationId the parent organization ID
1784            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1785            * @return the last matching organization
1786            * @throws NoSuchOrganizationException if a matching organization could not be found
1787            */
1788            public static Organization findByO_C_P_Last(long organizationId,
1789                    long companyId, long parentOrganizationId,
1790                    OrderByComparator<Organization> orderByComparator)
1791                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1792                    return getPersistence()
1793                                       .findByO_C_P_Last(organizationId, companyId,
1794                            parentOrganizationId, orderByComparator);
1795            }
1796    
1797            /**
1798            * Returns the last organization in the ordered set where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1799            *
1800            * @param organizationId the organization ID
1801            * @param companyId the company ID
1802            * @param parentOrganizationId the parent organization ID
1803            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1804            * @return the last matching organization, or <code>null</code> if a matching organization could not be found
1805            */
1806            public static Organization fetchByO_C_P_Last(long organizationId,
1807                    long companyId, long parentOrganizationId,
1808                    OrderByComparator<Organization> orderByComparator) {
1809                    return getPersistence()
1810                                       .fetchByO_C_P_Last(organizationId, companyId,
1811                            parentOrganizationId, orderByComparator);
1812            }
1813    
1814            /**
1815            * Returns all the organizations that the user has permission to view where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1816            *
1817            * @param organizationId the organization ID
1818            * @param companyId the company ID
1819            * @param parentOrganizationId the parent organization ID
1820            * @return the matching organizations that the user has permission to view
1821            */
1822            public static List<Organization> filterFindByO_C_P(long organizationId,
1823                    long companyId, long parentOrganizationId) {
1824                    return getPersistence()
1825                                       .filterFindByO_C_P(organizationId, companyId,
1826                            parentOrganizationId);
1827            }
1828    
1829            /**
1830            * Returns a range of all the organizations that the user has permission to view where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1831            *
1832            * <p>
1833            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1834            * </p>
1835            *
1836            * @param organizationId the organization ID
1837            * @param companyId the company ID
1838            * @param parentOrganizationId the parent organization ID
1839            * @param start the lower bound of the range of organizations
1840            * @param end the upper bound of the range of organizations (not inclusive)
1841            * @return the range of matching organizations that the user has permission to view
1842            */
1843            public static List<Organization> filterFindByO_C_P(long organizationId,
1844                    long companyId, long parentOrganizationId, int start, int end) {
1845                    return getPersistence()
1846                                       .filterFindByO_C_P(organizationId, companyId,
1847                            parentOrganizationId, start, end);
1848            }
1849    
1850            /**
1851            * Returns an ordered range of all the organizations that the user has permissions to view where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1852            *
1853            * <p>
1854            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1855            * </p>
1856            *
1857            * @param organizationId the organization ID
1858            * @param companyId the company ID
1859            * @param parentOrganizationId the parent organization ID
1860            * @param start the lower bound of the range of organizations
1861            * @param end the upper bound of the range of organizations (not inclusive)
1862            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1863            * @return the ordered range of matching organizations that the user has permission to view
1864            */
1865            public static List<Organization> filterFindByO_C_P(long organizationId,
1866                    long companyId, long parentOrganizationId, int start, int end,
1867                    OrderByComparator<Organization> orderByComparator) {
1868                    return getPersistence()
1869                                       .filterFindByO_C_P(organizationId, companyId,
1870                            parentOrganizationId, start, end, orderByComparator);
1871            }
1872    
1873            /**
1874            * Removes all the organizations where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63; from the database.
1875            *
1876            * @param organizationId the organization ID
1877            * @param companyId the company ID
1878            * @param parentOrganizationId the parent organization ID
1879            */
1880            public static void removeByO_C_P(long organizationId, long companyId,
1881                    long parentOrganizationId) {
1882                    getPersistence()
1883                            .removeByO_C_P(organizationId, companyId, parentOrganizationId);
1884            }
1885    
1886            /**
1887            * Returns the number of organizations where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1888            *
1889            * @param organizationId the organization ID
1890            * @param companyId the company ID
1891            * @param parentOrganizationId the parent organization ID
1892            * @return the number of matching organizations
1893            */
1894            public static int countByO_C_P(long organizationId, long companyId,
1895                    long parentOrganizationId) {
1896                    return getPersistence()
1897                                       .countByO_C_P(organizationId, companyId, parentOrganizationId);
1898            }
1899    
1900            /**
1901            * Returns the number of organizations that the user has permission to view where organizationId &gt; &#63; and companyId = &#63; and parentOrganizationId = &#63;.
1902            *
1903            * @param organizationId the organization ID
1904            * @param companyId the company ID
1905            * @param parentOrganizationId the parent organization ID
1906            * @return the number of matching organizations that the user has permission to view
1907            */
1908            public static int filterCountByO_C_P(long organizationId, long companyId,
1909                    long parentOrganizationId) {
1910                    return getPersistence()
1911                                       .filterCountByO_C_P(organizationId, companyId,
1912                            parentOrganizationId);
1913            }
1914    
1915            /**
1916            * Caches the organization in the entity cache if it is enabled.
1917            *
1918            * @param organization the organization
1919            */
1920            public static void cacheResult(Organization organization) {
1921                    getPersistence().cacheResult(organization);
1922            }
1923    
1924            /**
1925            * Caches the organizations in the entity cache if it is enabled.
1926            *
1927            * @param organizations the organizations
1928            */
1929            public static void cacheResult(List<Organization> organizations) {
1930                    getPersistence().cacheResult(organizations);
1931            }
1932    
1933            /**
1934            * Creates a new organization with the primary key. Does not add the organization to the database.
1935            *
1936            * @param organizationId the primary key for the new organization
1937            * @return the new organization
1938            */
1939            public static Organization create(long organizationId) {
1940                    return getPersistence().create(organizationId);
1941            }
1942    
1943            /**
1944            * Removes the organization with the primary key from the database. Also notifies the appropriate model listeners.
1945            *
1946            * @param organizationId the primary key of the organization
1947            * @return the organization that was removed
1948            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
1949            */
1950            public static Organization remove(long organizationId)
1951                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1952                    return getPersistence().remove(organizationId);
1953            }
1954    
1955            public static Organization updateImpl(Organization organization) {
1956                    return getPersistence().updateImpl(organization);
1957            }
1958    
1959            /**
1960            * Returns the organization with the primary key or throws a {@link NoSuchOrganizationException} if it could not be found.
1961            *
1962            * @param organizationId the primary key of the organization
1963            * @return the organization
1964            * @throws NoSuchOrganizationException if a organization with the primary key could not be found
1965            */
1966            public static Organization findByPrimaryKey(long organizationId)
1967                    throws com.liferay.portal.exception.NoSuchOrganizationException {
1968                    return getPersistence().findByPrimaryKey(organizationId);
1969            }
1970    
1971            /**
1972            * Returns the organization with the primary key or returns <code>null</code> if it could not be found.
1973            *
1974            * @param organizationId the primary key of the organization
1975            * @return the organization, or <code>null</code> if a organization with the primary key could not be found
1976            */
1977            public static Organization fetchByPrimaryKey(long organizationId) {
1978                    return getPersistence().fetchByPrimaryKey(organizationId);
1979            }
1980    
1981            public static java.util.Map<java.io.Serializable, Organization> fetchByPrimaryKeys(
1982                    java.util.Set<java.io.Serializable> primaryKeys) {
1983                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1984            }
1985    
1986            /**
1987            * Returns all the organizations.
1988            *
1989            * @return the organizations
1990            */
1991            public static List<Organization> findAll() {
1992                    return getPersistence().findAll();
1993            }
1994    
1995            /**
1996            * Returns a range of all the organizations.
1997            *
1998            * <p>
1999            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2000            * </p>
2001            *
2002            * @param start the lower bound of the range of organizations
2003            * @param end the upper bound of the range of organizations (not inclusive)
2004            * @return the range of organizations
2005            */
2006            public static List<Organization> findAll(int start, int end) {
2007                    return getPersistence().findAll(start, end);
2008            }
2009    
2010            /**
2011            * Returns an ordered range of all the organizations.
2012            *
2013            * <p>
2014            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2015            * </p>
2016            *
2017            * @param start the lower bound of the range of organizations
2018            * @param end the upper bound of the range of organizations (not inclusive)
2019            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2020            * @return the ordered range of organizations
2021            */
2022            public static List<Organization> findAll(int start, int end,
2023                    OrderByComparator<Organization> orderByComparator) {
2024                    return getPersistence().findAll(start, end, orderByComparator);
2025            }
2026    
2027            /**
2028            * Returns an ordered range of all the organizations.
2029            *
2030            * <p>
2031            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2032            * </p>
2033            *
2034            * @param start the lower bound of the range of organizations
2035            * @param end the upper bound of the range of organizations (not inclusive)
2036            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2037            * @param retrieveFromCache whether to retrieve from the finder cache
2038            * @return the ordered range of organizations
2039            */
2040            public static List<Organization> findAll(int start, int end,
2041                    OrderByComparator<Organization> orderByComparator,
2042                    boolean retrieveFromCache) {
2043                    return getPersistence()
2044                                       .findAll(start, end, orderByComparator, retrieveFromCache);
2045            }
2046    
2047            /**
2048            * Removes all the organizations from the database.
2049            */
2050            public static void removeAll() {
2051                    getPersistence().removeAll();
2052            }
2053    
2054            /**
2055            * Returns the number of organizations.
2056            *
2057            * @return the number of organizations
2058            */
2059            public static int countAll() {
2060                    return getPersistence().countAll();
2061            }
2062    
2063            /**
2064            * Returns the primaryKeys of groups associated with the organization.
2065            *
2066            * @param pk the primary key of the organization
2067            * @return long[] of the primaryKeys of groups associated with the organization
2068            */
2069            public static long[] getGroupPrimaryKeys(long pk) {
2070                    return getPersistence().getGroupPrimaryKeys(pk);
2071            }
2072    
2073            /**
2074            * Returns all the groups associated with the organization.
2075            *
2076            * @param pk the primary key of the organization
2077            * @return the groups associated with the organization
2078            */
2079            public static List<com.liferay.portal.model.Group> getGroups(long pk) {
2080                    return getPersistence().getGroups(pk);
2081            }
2082    
2083            /**
2084            * Returns a range of all the groups associated with the organization.
2085            *
2086            * <p>
2087            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2088            * </p>
2089            *
2090            * @param pk the primary key of the organization
2091            * @param start the lower bound of the range of organizations
2092            * @param end the upper bound of the range of organizations (not inclusive)
2093            * @return the range of groups associated with the organization
2094            */
2095            public static List<com.liferay.portal.model.Group> getGroups(long pk,
2096                    int start, int end) {
2097                    return getPersistence().getGroups(pk, start, end);
2098            }
2099    
2100            /**
2101            * Returns an ordered range of all the groups associated with the organization.
2102            *
2103            * <p>
2104            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2105            * </p>
2106            *
2107            * @param pk the primary key of the organization
2108            * @param start the lower bound of the range of organizations
2109            * @param end the upper bound of the range of organizations (not inclusive)
2110            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2111            * @return the ordered range of groups associated with the organization
2112            */
2113            public static List<com.liferay.portal.model.Group> getGroups(long pk,
2114                    int start, int end,
2115                    OrderByComparator<com.liferay.portal.model.Group> orderByComparator) {
2116                    return getPersistence().getGroups(pk, start, end, orderByComparator);
2117            }
2118    
2119            /**
2120            * Returns the number of groups associated with the organization.
2121            *
2122            * @param pk the primary key of the organization
2123            * @return the number of groups associated with the organization
2124            */
2125            public static int getGroupsSize(long pk) {
2126                    return getPersistence().getGroupsSize(pk);
2127            }
2128    
2129            /**
2130            * Returns <code>true</code> if the group is associated with the organization.
2131            *
2132            * @param pk the primary key of the organization
2133            * @param groupPK the primary key of the group
2134            * @return <code>true</code> if the group is associated with the organization; <code>false</code> otherwise
2135            */
2136            public static boolean containsGroup(long pk, long groupPK) {
2137                    return getPersistence().containsGroup(pk, groupPK);
2138            }
2139    
2140            /**
2141            * Returns <code>true</code> if the organization has any groups associated with it.
2142            *
2143            * @param pk the primary key of the organization to check for associations with groups
2144            * @return <code>true</code> if the organization has any groups associated with it; <code>false</code> otherwise
2145            */
2146            public static boolean containsGroups(long pk) {
2147                    return getPersistence().containsGroups(pk);
2148            }
2149    
2150            /**
2151            * Adds an association between the organization and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2152            *
2153            * @param pk the primary key of the organization
2154            * @param groupPK the primary key of the group
2155            */
2156            public static void addGroup(long pk, long groupPK) {
2157                    getPersistence().addGroup(pk, groupPK);
2158            }
2159    
2160            /**
2161            * Adds an association between the organization and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2162            *
2163            * @param pk the primary key of the organization
2164            * @param group the group
2165            */
2166            public static void addGroup(long pk, com.liferay.portal.model.Group group) {
2167                    getPersistence().addGroup(pk, group);
2168            }
2169    
2170            /**
2171            * Adds an association between the organization and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2172            *
2173            * @param pk the primary key of the organization
2174            * @param groupPKs the primary keys of the groups
2175            */
2176            public static void addGroups(long pk, long[] groupPKs) {
2177                    getPersistence().addGroups(pk, groupPKs);
2178            }
2179    
2180            /**
2181            * Adds an association between the organization and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2182            *
2183            * @param pk the primary key of the organization
2184            * @param groups the groups
2185            */
2186            public static void addGroups(long pk,
2187                    List<com.liferay.portal.model.Group> groups) {
2188                    getPersistence().addGroups(pk, groups);
2189            }
2190    
2191            /**
2192            * Clears all associations between the organization and its groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2193            *
2194            * @param pk the primary key of the organization to clear the associated groups from
2195            */
2196            public static void clearGroups(long pk) {
2197                    getPersistence().clearGroups(pk);
2198            }
2199    
2200            /**
2201            * Removes the association between the organization and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2202            *
2203            * @param pk the primary key of the organization
2204            * @param groupPK the primary key of the group
2205            */
2206            public static void removeGroup(long pk, long groupPK) {
2207                    getPersistence().removeGroup(pk, groupPK);
2208            }
2209    
2210            /**
2211            * Removes the association between the organization and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2212            *
2213            * @param pk the primary key of the organization
2214            * @param group the group
2215            */
2216            public static void removeGroup(long pk, com.liferay.portal.model.Group group) {
2217                    getPersistence().removeGroup(pk, group);
2218            }
2219    
2220            /**
2221            * Removes the association between the organization and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2222            *
2223            * @param pk the primary key of the organization
2224            * @param groupPKs the primary keys of the groups
2225            */
2226            public static void removeGroups(long pk, long[] groupPKs) {
2227                    getPersistence().removeGroups(pk, groupPKs);
2228            }
2229    
2230            /**
2231            * Removes the association between the organization and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2232            *
2233            * @param pk the primary key of the organization
2234            * @param groups the groups
2235            */
2236            public static void removeGroups(long pk,
2237                    List<com.liferay.portal.model.Group> groups) {
2238                    getPersistence().removeGroups(pk, groups);
2239            }
2240    
2241            /**
2242            * Sets the groups associated with the organization, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2243            *
2244            * @param pk the primary key of the organization
2245            * @param groupPKs the primary keys of the groups to be associated with the organization
2246            */
2247            public static void setGroups(long pk, long[] groupPKs) {
2248                    getPersistence().setGroups(pk, groupPKs);
2249            }
2250    
2251            /**
2252            * Sets the groups associated with the organization, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2253            *
2254            * @param pk the primary key of the organization
2255            * @param groups the groups to be associated with the organization
2256            */
2257            public static void setGroups(long pk,
2258                    List<com.liferay.portal.model.Group> groups) {
2259                    getPersistence().setGroups(pk, groups);
2260            }
2261    
2262            /**
2263            * Returns the primaryKeys of users associated with the organization.
2264            *
2265            * @param pk the primary key of the organization
2266            * @return long[] of the primaryKeys of users associated with the organization
2267            */
2268            public static long[] getUserPrimaryKeys(long pk) {
2269                    return getPersistence().getUserPrimaryKeys(pk);
2270            }
2271    
2272            /**
2273            * Returns all the users associated with the organization.
2274            *
2275            * @param pk the primary key of the organization
2276            * @return the users associated with the organization
2277            */
2278            public static List<com.liferay.portal.model.User> getUsers(long pk) {
2279                    return getPersistence().getUsers(pk);
2280            }
2281    
2282            /**
2283            * Returns a range of all the users associated with the organization.
2284            *
2285            * <p>
2286            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2287            * </p>
2288            *
2289            * @param pk the primary key of the organization
2290            * @param start the lower bound of the range of organizations
2291            * @param end the upper bound of the range of organizations (not inclusive)
2292            * @return the range of users associated with the organization
2293            */
2294            public static List<com.liferay.portal.model.User> getUsers(long pk,
2295                    int start, int end) {
2296                    return getPersistence().getUsers(pk, start, end);
2297            }
2298    
2299            /**
2300            * Returns an ordered range of all the users associated with the organization.
2301            *
2302            * <p>
2303            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrganizationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2304            * </p>
2305            *
2306            * @param pk the primary key of the organization
2307            * @param start the lower bound of the range of organizations
2308            * @param end the upper bound of the range of organizations (not inclusive)
2309            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2310            * @return the ordered range of users associated with the organization
2311            */
2312            public static List<com.liferay.portal.model.User> getUsers(long pk,
2313                    int start, int end,
2314                    OrderByComparator<com.liferay.portal.model.User> orderByComparator) {
2315                    return getPersistence().getUsers(pk, start, end, orderByComparator);
2316            }
2317    
2318            /**
2319            * Returns the number of users associated with the organization.
2320            *
2321            * @param pk the primary key of the organization
2322            * @return the number of users associated with the organization
2323            */
2324            public static int getUsersSize(long pk) {
2325                    return getPersistence().getUsersSize(pk);
2326            }
2327    
2328            /**
2329            * Returns <code>true</code> if the user is associated with the organization.
2330            *
2331            * @param pk the primary key of the organization
2332            * @param userPK the primary key of the user
2333            * @return <code>true</code> if the user is associated with the organization; <code>false</code> otherwise
2334            */
2335            public static boolean containsUser(long pk, long userPK) {
2336                    return getPersistence().containsUser(pk, userPK);
2337            }
2338    
2339            /**
2340            * Returns <code>true</code> if the organization has any users associated with it.
2341            *
2342            * @param pk the primary key of the organization to check for associations with users
2343            * @return <code>true</code> if the organization has any users associated with it; <code>false</code> otherwise
2344            */
2345            public static boolean containsUsers(long pk) {
2346                    return getPersistence().containsUsers(pk);
2347            }
2348    
2349            /**
2350            * Adds an association between the organization and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2351            *
2352            * @param pk the primary key of the organization
2353            * @param userPK the primary key of the user
2354            */
2355            public static void addUser(long pk, long userPK) {
2356                    getPersistence().addUser(pk, userPK);
2357            }
2358    
2359            /**
2360            * Adds an association between the organization and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2361            *
2362            * @param pk the primary key of the organization
2363            * @param user the user
2364            */
2365            public static void addUser(long pk, com.liferay.portal.model.User user) {
2366                    getPersistence().addUser(pk, user);
2367            }
2368    
2369            /**
2370            * Adds an association between the organization and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2371            *
2372            * @param pk the primary key of the organization
2373            * @param userPKs the primary keys of the users
2374            */
2375            public static void addUsers(long pk, long[] userPKs) {
2376                    getPersistence().addUsers(pk, userPKs);
2377            }
2378    
2379            /**
2380            * Adds an association between the organization and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2381            *
2382            * @param pk the primary key of the organization
2383            * @param users the users
2384            */
2385            public static void addUsers(long pk,
2386                    List<com.liferay.portal.model.User> users) {
2387                    getPersistence().addUsers(pk, users);
2388            }
2389    
2390            /**
2391            * Clears all associations between the organization and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2392            *
2393            * @param pk the primary key of the organization to clear the associated users from
2394            */
2395            public static void clearUsers(long pk) {
2396                    getPersistence().clearUsers(pk);
2397            }
2398    
2399            /**
2400            * Removes the association between the organization and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2401            *
2402            * @param pk the primary key of the organization
2403            * @param userPK the primary key of the user
2404            */
2405            public static void removeUser(long pk, long userPK) {
2406                    getPersistence().removeUser(pk, userPK);
2407            }
2408    
2409            /**
2410            * Removes the association between the organization and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2411            *
2412            * @param pk the primary key of the organization
2413            * @param user the user
2414            */
2415            public static void removeUser(long pk, com.liferay.portal.model.User user) {
2416                    getPersistence().removeUser(pk, user);
2417            }
2418    
2419            /**
2420            * Removes the association between the organization and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2421            *
2422            * @param pk the primary key of the organization
2423            * @param userPKs the primary keys of the users
2424            */
2425            public static void removeUsers(long pk, long[] userPKs) {
2426                    getPersistence().removeUsers(pk, userPKs);
2427            }
2428    
2429            /**
2430            * Removes the association between the organization and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2431            *
2432            * @param pk the primary key of the organization
2433            * @param users the users
2434            */
2435            public static void removeUsers(long pk,
2436                    List<com.liferay.portal.model.User> users) {
2437                    getPersistence().removeUsers(pk, users);
2438            }
2439    
2440            /**
2441            * Sets the users associated with the organization, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2442            *
2443            * @param pk the primary key of the organization
2444            * @param userPKs the primary keys of the users to be associated with the organization
2445            */
2446            public static void setUsers(long pk, long[] userPKs) {
2447                    getPersistence().setUsers(pk, userPKs);
2448            }
2449    
2450            /**
2451            * Sets the users associated with the organization, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2452            *
2453            * @param pk the primary key of the organization
2454            * @param users the users to be associated with the organization
2455            */
2456            public static void setUsers(long pk,
2457                    List<com.liferay.portal.model.User> users) {
2458                    getPersistence().setUsers(pk, users);
2459            }
2460    
2461            public static java.util.Set<java.lang.String> getBadColumnNames() {
2462                    return getPersistence().getBadColumnNames();
2463            }
2464    
2465            public static OrganizationPersistence getPersistence() {
2466                    if (_persistence == null) {
2467                            _persistence = (OrganizationPersistence)PortalBeanLocatorUtil.locate(OrganizationPersistence.class.getName());
2468    
2469                            ReferenceRegistry.registerReference(OrganizationUtil.class,
2470                                    "_persistence");
2471                    }
2472    
2473                    return _persistence;
2474            }
2475    
2476            private static OrganizationPersistence _persistence;
2477    }