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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ? 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ? 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 = ? and parentOrganizationId = ?. 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 = ? and parentOrganizationId = ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ? 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 = ? and treePath LIKE ?. 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 = ? and treePath LIKE ?. 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 = ? and name = ? 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 = ? and name = ? 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 = ? and name = ? 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 = ? and name = ? 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 = ? and name = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ? 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 > ? and companyId = ? and parentOrganizationId = ?. 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 > ? and companyId = ? and parentOrganizationId = ?. 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 }