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.Group; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the group service. This utility wraps {@link com.liferay.portal.service.persistence.impl.GroupPersistenceImpl} 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 GroupPersistence 037 * @see com.liferay.portal.service.persistence.impl.GroupPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class GroupUtil { 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(Group group) { 059 getPersistence().clearCache(group); 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<Group> findWithDynamicQuery(DynamicQuery dynamicQuery) { 073 return getPersistence().findWithDynamicQuery(dynamicQuery); 074 } 075 076 /** 077 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 078 */ 079 public static List<Group> findWithDynamicQuery(DynamicQuery dynamicQuery, 080 int start, int end) { 081 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 082 } 083 084 /** 085 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 086 */ 087 public static List<Group> findWithDynamicQuery(DynamicQuery dynamicQuery, 088 int start, int end, OrderByComparator<Group> orderByComparator) { 089 return getPersistence() 090 .findWithDynamicQuery(dynamicQuery, start, end, 091 orderByComparator); 092 } 093 094 /** 095 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 096 */ 097 public static Group update(Group group) { 098 return getPersistence().update(group); 099 } 100 101 /** 102 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 103 */ 104 public static Group update(Group group, ServiceContext serviceContext) { 105 return getPersistence().update(group, serviceContext); 106 } 107 108 /** 109 * Returns all the groups where uuid = ?. 110 * 111 * @param uuid the uuid 112 * @return the matching groups 113 */ 114 public static List<Group> findByUuid(java.lang.String uuid) { 115 return getPersistence().findByUuid(uuid); 116 } 117 118 /** 119 * Returns a range of all the groups where uuid = ?. 120 * 121 * <p> 122 * 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 GroupModelImpl}. 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. 123 * </p> 124 * 125 * @param uuid the uuid 126 * @param start the lower bound of the range of groups 127 * @param end the upper bound of the range of groups (not inclusive) 128 * @return the range of matching groups 129 */ 130 public static List<Group> findByUuid(java.lang.String uuid, int start, 131 int end) { 132 return getPersistence().findByUuid(uuid, start, end); 133 } 134 135 /** 136 * Returns an ordered range of all the groups where uuid = ?. 137 * 138 * <p> 139 * 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 GroupModelImpl}. 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. 140 * </p> 141 * 142 * @param uuid the uuid 143 * @param start the lower bound of the range of groups 144 * @param end the upper bound of the range of groups (not inclusive) 145 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 146 * @return the ordered range of matching groups 147 */ 148 public static List<Group> findByUuid(java.lang.String uuid, int start, 149 int end, OrderByComparator<Group> orderByComparator) { 150 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 151 } 152 153 /** 154 * Returns the first group in the ordered set where uuid = ?. 155 * 156 * @param uuid the uuid 157 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 158 * @return the first matching group 159 * @throws NoSuchGroupException if a matching group could not be found 160 */ 161 public static Group findByUuid_First(java.lang.String uuid, 162 OrderByComparator<Group> orderByComparator) 163 throws com.liferay.portal.NoSuchGroupException { 164 return getPersistence().findByUuid_First(uuid, orderByComparator); 165 } 166 167 /** 168 * Returns the first group in the ordered set where uuid = ?. 169 * 170 * @param uuid the uuid 171 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 172 * @return the first matching group, or <code>null</code> if a matching group could not be found 173 */ 174 public static Group fetchByUuid_First(java.lang.String uuid, 175 OrderByComparator<Group> orderByComparator) { 176 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 177 } 178 179 /** 180 * Returns the last group in the ordered set where uuid = ?. 181 * 182 * @param uuid the uuid 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the last matching group 185 * @throws NoSuchGroupException if a matching group could not be found 186 */ 187 public static Group findByUuid_Last(java.lang.String uuid, 188 OrderByComparator<Group> orderByComparator) 189 throws com.liferay.portal.NoSuchGroupException { 190 return getPersistence().findByUuid_Last(uuid, orderByComparator); 191 } 192 193 /** 194 * Returns the last group in the ordered set where uuid = ?. 195 * 196 * @param uuid the uuid 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the last matching group, or <code>null</code> if a matching group could not be found 199 */ 200 public static Group fetchByUuid_Last(java.lang.String uuid, 201 OrderByComparator<Group> orderByComparator) { 202 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 203 } 204 205 /** 206 * Returns the groups before and after the current group in the ordered set where uuid = ?. 207 * 208 * @param groupId the primary key of the current group 209 * @param uuid the uuid 210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 211 * @return the previous, current, and next group 212 * @throws NoSuchGroupException if a group with the primary key could not be found 213 */ 214 public static Group[] findByUuid_PrevAndNext(long groupId, 215 java.lang.String uuid, OrderByComparator<Group> orderByComparator) 216 throws com.liferay.portal.NoSuchGroupException { 217 return getPersistence() 218 .findByUuid_PrevAndNext(groupId, uuid, orderByComparator); 219 } 220 221 /** 222 * Removes all the groups where uuid = ? from the database. 223 * 224 * @param uuid the uuid 225 */ 226 public static void removeByUuid(java.lang.String uuid) { 227 getPersistence().removeByUuid(uuid); 228 } 229 230 /** 231 * Returns the number of groups where uuid = ?. 232 * 233 * @param uuid the uuid 234 * @return the number of matching groups 235 */ 236 public static int countByUuid(java.lang.String uuid) { 237 return getPersistence().countByUuid(uuid); 238 } 239 240 /** 241 * Returns the group where uuid = ? and groupId = ? or throws a {@link NoSuchGroupException} if it could not be found. 242 * 243 * @param uuid the uuid 244 * @param groupId the group ID 245 * @return the matching group 246 * @throws NoSuchGroupException if a matching group could not be found 247 */ 248 public static Group findByUUID_G(java.lang.String uuid, long groupId) 249 throws com.liferay.portal.NoSuchGroupException { 250 return getPersistence().findByUUID_G(uuid, groupId); 251 } 252 253 /** 254 * Returns the group where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 255 * 256 * @param uuid the uuid 257 * @param groupId the group ID 258 * @return the matching group, or <code>null</code> if a matching group could not be found 259 */ 260 public static Group fetchByUUID_G(java.lang.String uuid, long groupId) { 261 return getPersistence().fetchByUUID_G(uuid, groupId); 262 } 263 264 /** 265 * Returns the group where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 266 * 267 * @param uuid the uuid 268 * @param groupId the group ID 269 * @param retrieveFromCache whether to use the finder cache 270 * @return the matching group, or <code>null</code> if a matching group could not be found 271 */ 272 public static Group fetchByUUID_G(java.lang.String uuid, long groupId, 273 boolean retrieveFromCache) { 274 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 275 } 276 277 /** 278 * Removes the group where uuid = ? and groupId = ? from the database. 279 * 280 * @param uuid the uuid 281 * @param groupId the group ID 282 * @return the group that was removed 283 */ 284 public static Group removeByUUID_G(java.lang.String uuid, long groupId) 285 throws com.liferay.portal.NoSuchGroupException { 286 return getPersistence().removeByUUID_G(uuid, groupId); 287 } 288 289 /** 290 * Returns the number of groups where uuid = ? and groupId = ?. 291 * 292 * @param uuid the uuid 293 * @param groupId the group ID 294 * @return the number of matching groups 295 */ 296 public static int countByUUID_G(java.lang.String uuid, long groupId) { 297 return getPersistence().countByUUID_G(uuid, groupId); 298 } 299 300 /** 301 * Returns all the groups where uuid = ? and companyId = ?. 302 * 303 * @param uuid the uuid 304 * @param companyId the company ID 305 * @return the matching groups 306 */ 307 public static List<Group> findByUuid_C(java.lang.String uuid, long companyId) { 308 return getPersistence().findByUuid_C(uuid, companyId); 309 } 310 311 /** 312 * Returns a range of all the groups where uuid = ? and companyId = ?. 313 * 314 * <p> 315 * 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 GroupModelImpl}. 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. 316 * </p> 317 * 318 * @param uuid the uuid 319 * @param companyId the company ID 320 * @param start the lower bound of the range of groups 321 * @param end the upper bound of the range of groups (not inclusive) 322 * @return the range of matching groups 323 */ 324 public static List<Group> findByUuid_C(java.lang.String uuid, 325 long companyId, int start, int end) { 326 return getPersistence().findByUuid_C(uuid, companyId, start, end); 327 } 328 329 /** 330 * Returns an ordered range of all the groups where uuid = ? and companyId = ?. 331 * 332 * <p> 333 * 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 GroupModelImpl}. 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. 334 * </p> 335 * 336 * @param uuid the uuid 337 * @param companyId the company ID 338 * @param start the lower bound of the range of groups 339 * @param end the upper bound of the range of groups (not inclusive) 340 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 341 * @return the ordered range of matching groups 342 */ 343 public static List<Group> findByUuid_C(java.lang.String uuid, 344 long companyId, int start, int end, 345 OrderByComparator<Group> orderByComparator) { 346 return getPersistence() 347 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 348 } 349 350 /** 351 * Returns the first group in the ordered set where uuid = ? and companyId = ?. 352 * 353 * @param uuid the uuid 354 * @param companyId the company ID 355 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 356 * @return the first matching group 357 * @throws NoSuchGroupException if a matching group could not be found 358 */ 359 public static Group findByUuid_C_First(java.lang.String uuid, 360 long companyId, OrderByComparator<Group> orderByComparator) 361 throws com.liferay.portal.NoSuchGroupException { 362 return getPersistence() 363 .findByUuid_C_First(uuid, companyId, orderByComparator); 364 } 365 366 /** 367 * Returns the first group in the ordered set where uuid = ? and companyId = ?. 368 * 369 * @param uuid the uuid 370 * @param companyId the company ID 371 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 372 * @return the first matching group, or <code>null</code> if a matching group could not be found 373 */ 374 public static Group fetchByUuid_C_First(java.lang.String uuid, 375 long companyId, OrderByComparator<Group> orderByComparator) { 376 return getPersistence() 377 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 378 } 379 380 /** 381 * Returns the last group in the ordered set where uuid = ? and companyId = ?. 382 * 383 * @param uuid the uuid 384 * @param companyId the company ID 385 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 386 * @return the last matching group 387 * @throws NoSuchGroupException if a matching group could not be found 388 */ 389 public static Group findByUuid_C_Last(java.lang.String uuid, 390 long companyId, OrderByComparator<Group> orderByComparator) 391 throws com.liferay.portal.NoSuchGroupException { 392 return getPersistence() 393 .findByUuid_C_Last(uuid, companyId, orderByComparator); 394 } 395 396 /** 397 * Returns the last group in the ordered set where uuid = ? and companyId = ?. 398 * 399 * @param uuid the uuid 400 * @param companyId the company ID 401 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 402 * @return the last matching group, or <code>null</code> if a matching group could not be found 403 */ 404 public static Group fetchByUuid_C_Last(java.lang.String uuid, 405 long companyId, OrderByComparator<Group> orderByComparator) { 406 return getPersistence() 407 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 408 } 409 410 /** 411 * Returns the groups before and after the current group in the ordered set where uuid = ? and companyId = ?. 412 * 413 * @param groupId the primary key of the current group 414 * @param uuid the uuid 415 * @param companyId the company ID 416 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 417 * @return the previous, current, and next group 418 * @throws NoSuchGroupException if a group with the primary key could not be found 419 */ 420 public static Group[] findByUuid_C_PrevAndNext(long groupId, 421 java.lang.String uuid, long companyId, 422 OrderByComparator<Group> orderByComparator) 423 throws com.liferay.portal.NoSuchGroupException { 424 return getPersistence() 425 .findByUuid_C_PrevAndNext(groupId, uuid, companyId, 426 orderByComparator); 427 } 428 429 /** 430 * Removes all the groups where uuid = ? and companyId = ? from the database. 431 * 432 * @param uuid the uuid 433 * @param companyId the company ID 434 */ 435 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 436 getPersistence().removeByUuid_C(uuid, companyId); 437 } 438 439 /** 440 * Returns the number of groups where uuid = ? and companyId = ?. 441 * 442 * @param uuid the uuid 443 * @param companyId the company ID 444 * @return the number of matching groups 445 */ 446 public static int countByUuid_C(java.lang.String uuid, long companyId) { 447 return getPersistence().countByUuid_C(uuid, companyId); 448 } 449 450 /** 451 * Returns all the groups where companyId = ?. 452 * 453 * @param companyId the company ID 454 * @return the matching groups 455 */ 456 public static List<Group> findByCompanyId(long companyId) { 457 return getPersistence().findByCompanyId(companyId); 458 } 459 460 /** 461 * Returns a range of all the groups where companyId = ?. 462 * 463 * <p> 464 * 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 GroupModelImpl}. 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. 465 * </p> 466 * 467 * @param companyId the company ID 468 * @param start the lower bound of the range of groups 469 * @param end the upper bound of the range of groups (not inclusive) 470 * @return the range of matching groups 471 */ 472 public static List<Group> findByCompanyId(long companyId, int start, int end) { 473 return getPersistence().findByCompanyId(companyId, start, end); 474 } 475 476 /** 477 * Returns an ordered range of all the groups where companyId = ?. 478 * 479 * <p> 480 * 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 GroupModelImpl}. 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. 481 * </p> 482 * 483 * @param companyId the company ID 484 * @param start the lower bound of the range of groups 485 * @param end the upper bound of the range of groups (not inclusive) 486 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 487 * @return the ordered range of matching groups 488 */ 489 public static List<Group> findByCompanyId(long companyId, int start, 490 int end, OrderByComparator<Group> orderByComparator) { 491 return getPersistence() 492 .findByCompanyId(companyId, start, end, orderByComparator); 493 } 494 495 /** 496 * Returns the first group in the ordered set where companyId = ?. 497 * 498 * @param companyId the company ID 499 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 500 * @return the first matching group 501 * @throws NoSuchGroupException if a matching group could not be found 502 */ 503 public static Group findByCompanyId_First(long companyId, 504 OrderByComparator<Group> orderByComparator) 505 throws com.liferay.portal.NoSuchGroupException { 506 return getPersistence() 507 .findByCompanyId_First(companyId, orderByComparator); 508 } 509 510 /** 511 * Returns the first group in the ordered set where companyId = ?. 512 * 513 * @param companyId the company ID 514 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 515 * @return the first matching group, or <code>null</code> if a matching group could not be found 516 */ 517 public static Group fetchByCompanyId_First(long companyId, 518 OrderByComparator<Group> orderByComparator) { 519 return getPersistence() 520 .fetchByCompanyId_First(companyId, orderByComparator); 521 } 522 523 /** 524 * Returns the last group in the ordered set where companyId = ?. 525 * 526 * @param companyId the company ID 527 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 528 * @return the last matching group 529 * @throws NoSuchGroupException if a matching group could not be found 530 */ 531 public static Group findByCompanyId_Last(long companyId, 532 OrderByComparator<Group> orderByComparator) 533 throws com.liferay.portal.NoSuchGroupException { 534 return getPersistence() 535 .findByCompanyId_Last(companyId, orderByComparator); 536 } 537 538 /** 539 * Returns the last group in the ordered set where companyId = ?. 540 * 541 * @param companyId the company ID 542 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 543 * @return the last matching group, or <code>null</code> if a matching group could not be found 544 */ 545 public static Group fetchByCompanyId_Last(long companyId, 546 OrderByComparator<Group> orderByComparator) { 547 return getPersistence() 548 .fetchByCompanyId_Last(companyId, orderByComparator); 549 } 550 551 /** 552 * Returns the groups before and after the current group in the ordered set where companyId = ?. 553 * 554 * @param groupId the primary key of the current group 555 * @param companyId the company ID 556 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 557 * @return the previous, current, and next group 558 * @throws NoSuchGroupException if a group with the primary key could not be found 559 */ 560 public static Group[] findByCompanyId_PrevAndNext(long groupId, 561 long companyId, OrderByComparator<Group> orderByComparator) 562 throws com.liferay.portal.NoSuchGroupException { 563 return getPersistence() 564 .findByCompanyId_PrevAndNext(groupId, companyId, 565 orderByComparator); 566 } 567 568 /** 569 * Removes all the groups where companyId = ? from the database. 570 * 571 * @param companyId the company ID 572 */ 573 public static void removeByCompanyId(long companyId) { 574 getPersistence().removeByCompanyId(companyId); 575 } 576 577 /** 578 * Returns the number of groups where companyId = ?. 579 * 580 * @param companyId the company ID 581 * @return the number of matching groups 582 */ 583 public static int countByCompanyId(long companyId) { 584 return getPersistence().countByCompanyId(companyId); 585 } 586 587 /** 588 * Returns the group where liveGroupId = ? or throws a {@link NoSuchGroupException} if it could not be found. 589 * 590 * @param liveGroupId the live group ID 591 * @return the matching group 592 * @throws NoSuchGroupException if a matching group could not be found 593 */ 594 public static Group findByLiveGroupId(long liveGroupId) 595 throws com.liferay.portal.NoSuchGroupException { 596 return getPersistence().findByLiveGroupId(liveGroupId); 597 } 598 599 /** 600 * Returns the group where liveGroupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 601 * 602 * @param liveGroupId the live group ID 603 * @return the matching group, or <code>null</code> if a matching group could not be found 604 */ 605 public static Group fetchByLiveGroupId(long liveGroupId) { 606 return getPersistence().fetchByLiveGroupId(liveGroupId); 607 } 608 609 /** 610 * Returns the group where liveGroupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 611 * 612 * @param liveGroupId the live group ID 613 * @param retrieveFromCache whether to use the finder cache 614 * @return the matching group, or <code>null</code> if a matching group could not be found 615 */ 616 public static Group fetchByLiveGroupId(long liveGroupId, 617 boolean retrieveFromCache) { 618 return getPersistence() 619 .fetchByLiveGroupId(liveGroupId, retrieveFromCache); 620 } 621 622 /** 623 * Removes the group where liveGroupId = ? from the database. 624 * 625 * @param liveGroupId the live group ID 626 * @return the group that was removed 627 */ 628 public static Group removeByLiveGroupId(long liveGroupId) 629 throws com.liferay.portal.NoSuchGroupException { 630 return getPersistence().removeByLiveGroupId(liveGroupId); 631 } 632 633 /** 634 * Returns the number of groups where liveGroupId = ?. 635 * 636 * @param liveGroupId the live group ID 637 * @return the number of matching groups 638 */ 639 public static int countByLiveGroupId(long liveGroupId) { 640 return getPersistence().countByLiveGroupId(liveGroupId); 641 } 642 643 /** 644 * Returns all the groups where companyId = ? and classNameId = ?. 645 * 646 * @param companyId the company ID 647 * @param classNameId the class name ID 648 * @return the matching groups 649 */ 650 public static List<Group> findByC_C(long companyId, long classNameId) { 651 return getPersistence().findByC_C(companyId, classNameId); 652 } 653 654 /** 655 * Returns a range of all the groups where companyId = ? and classNameId = ?. 656 * 657 * <p> 658 * 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 GroupModelImpl}. 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. 659 * </p> 660 * 661 * @param companyId the company ID 662 * @param classNameId the class name ID 663 * @param start the lower bound of the range of groups 664 * @param end the upper bound of the range of groups (not inclusive) 665 * @return the range of matching groups 666 */ 667 public static List<Group> findByC_C(long companyId, long classNameId, 668 int start, int end) { 669 return getPersistence().findByC_C(companyId, classNameId, start, end); 670 } 671 672 /** 673 * Returns an ordered range of all the groups where companyId = ? and classNameId = ?. 674 * 675 * <p> 676 * 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 GroupModelImpl}. 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. 677 * </p> 678 * 679 * @param companyId the company ID 680 * @param classNameId the class name ID 681 * @param start the lower bound of the range of groups 682 * @param end the upper bound of the range of groups (not inclusive) 683 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 684 * @return the ordered range of matching groups 685 */ 686 public static List<Group> findByC_C(long companyId, long classNameId, 687 int start, int end, OrderByComparator<Group> orderByComparator) { 688 return getPersistence() 689 .findByC_C(companyId, classNameId, start, end, 690 orderByComparator); 691 } 692 693 /** 694 * Returns the first group in the ordered set where companyId = ? and classNameId = ?. 695 * 696 * @param companyId the company ID 697 * @param classNameId the class name ID 698 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 699 * @return the first matching group 700 * @throws NoSuchGroupException if a matching group could not be found 701 */ 702 public static Group findByC_C_First(long companyId, long classNameId, 703 OrderByComparator<Group> orderByComparator) 704 throws com.liferay.portal.NoSuchGroupException { 705 return getPersistence() 706 .findByC_C_First(companyId, classNameId, orderByComparator); 707 } 708 709 /** 710 * Returns the first group in the ordered set where companyId = ? and classNameId = ?. 711 * 712 * @param companyId the company ID 713 * @param classNameId the class name ID 714 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 715 * @return the first matching group, or <code>null</code> if a matching group could not be found 716 */ 717 public static Group fetchByC_C_First(long companyId, long classNameId, 718 OrderByComparator<Group> orderByComparator) { 719 return getPersistence() 720 .fetchByC_C_First(companyId, classNameId, orderByComparator); 721 } 722 723 /** 724 * Returns the last group in the ordered set where companyId = ? and classNameId = ?. 725 * 726 * @param companyId the company ID 727 * @param classNameId the class name ID 728 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 729 * @return the last matching group 730 * @throws NoSuchGroupException if a matching group could not be found 731 */ 732 public static Group findByC_C_Last(long companyId, long classNameId, 733 OrderByComparator<Group> orderByComparator) 734 throws com.liferay.portal.NoSuchGroupException { 735 return getPersistence() 736 .findByC_C_Last(companyId, classNameId, orderByComparator); 737 } 738 739 /** 740 * Returns the last group in the ordered set where companyId = ? and classNameId = ?. 741 * 742 * @param companyId the company ID 743 * @param classNameId the class name ID 744 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 745 * @return the last matching group, or <code>null</code> if a matching group could not be found 746 */ 747 public static Group fetchByC_C_Last(long companyId, long classNameId, 748 OrderByComparator<Group> orderByComparator) { 749 return getPersistence() 750 .fetchByC_C_Last(companyId, classNameId, orderByComparator); 751 } 752 753 /** 754 * Returns the groups before and after the current group in the ordered set where companyId = ? and classNameId = ?. 755 * 756 * @param groupId the primary key of the current group 757 * @param companyId the company ID 758 * @param classNameId the class name ID 759 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 760 * @return the previous, current, and next group 761 * @throws NoSuchGroupException if a group with the primary key could not be found 762 */ 763 public static Group[] findByC_C_PrevAndNext(long groupId, long companyId, 764 long classNameId, OrderByComparator<Group> orderByComparator) 765 throws com.liferay.portal.NoSuchGroupException { 766 return getPersistence() 767 .findByC_C_PrevAndNext(groupId, companyId, classNameId, 768 orderByComparator); 769 } 770 771 /** 772 * Removes all the groups where companyId = ? and classNameId = ? from the database. 773 * 774 * @param companyId the company ID 775 * @param classNameId the class name ID 776 */ 777 public static void removeByC_C(long companyId, long classNameId) { 778 getPersistence().removeByC_C(companyId, classNameId); 779 } 780 781 /** 782 * Returns the number of groups where companyId = ? and classNameId = ?. 783 * 784 * @param companyId the company ID 785 * @param classNameId the class name ID 786 * @return the number of matching groups 787 */ 788 public static int countByC_C(long companyId, long classNameId) { 789 return getPersistence().countByC_C(companyId, classNameId); 790 } 791 792 /** 793 * Returns all the groups where companyId = ? and parentGroupId = ?. 794 * 795 * @param companyId the company ID 796 * @param parentGroupId the parent group ID 797 * @return the matching groups 798 */ 799 public static List<Group> findByC_P(long companyId, long parentGroupId) { 800 return getPersistence().findByC_P(companyId, parentGroupId); 801 } 802 803 /** 804 * Returns a range of all the groups where companyId = ? and parentGroupId = ?. 805 * 806 * <p> 807 * 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 GroupModelImpl}. 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. 808 * </p> 809 * 810 * @param companyId the company ID 811 * @param parentGroupId the parent group ID 812 * @param start the lower bound of the range of groups 813 * @param end the upper bound of the range of groups (not inclusive) 814 * @return the range of matching groups 815 */ 816 public static List<Group> findByC_P(long companyId, long parentGroupId, 817 int start, int end) { 818 return getPersistence().findByC_P(companyId, parentGroupId, start, end); 819 } 820 821 /** 822 * Returns an ordered range of all the groups where companyId = ? and parentGroupId = ?. 823 * 824 * <p> 825 * 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 GroupModelImpl}. 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. 826 * </p> 827 * 828 * @param companyId the company ID 829 * @param parentGroupId the parent group ID 830 * @param start the lower bound of the range of groups 831 * @param end the upper bound of the range of groups (not inclusive) 832 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 833 * @return the ordered range of matching groups 834 */ 835 public static List<Group> findByC_P(long companyId, long parentGroupId, 836 int start, int end, OrderByComparator<Group> orderByComparator) { 837 return getPersistence() 838 .findByC_P(companyId, parentGroupId, start, end, 839 orderByComparator); 840 } 841 842 /** 843 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ?. 844 * 845 * @param companyId the company ID 846 * @param parentGroupId the parent group ID 847 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 848 * @return the first matching group 849 * @throws NoSuchGroupException if a matching group could not be found 850 */ 851 public static Group findByC_P_First(long companyId, long parentGroupId, 852 OrderByComparator<Group> orderByComparator) 853 throws com.liferay.portal.NoSuchGroupException { 854 return getPersistence() 855 .findByC_P_First(companyId, parentGroupId, orderByComparator); 856 } 857 858 /** 859 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ?. 860 * 861 * @param companyId the company ID 862 * @param parentGroupId the parent group ID 863 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 864 * @return the first matching group, or <code>null</code> if a matching group could not be found 865 */ 866 public static Group fetchByC_P_First(long companyId, long parentGroupId, 867 OrderByComparator<Group> orderByComparator) { 868 return getPersistence() 869 .fetchByC_P_First(companyId, parentGroupId, orderByComparator); 870 } 871 872 /** 873 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ?. 874 * 875 * @param companyId the company ID 876 * @param parentGroupId the parent group ID 877 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 878 * @return the last matching group 879 * @throws NoSuchGroupException if a matching group could not be found 880 */ 881 public static Group findByC_P_Last(long companyId, long parentGroupId, 882 OrderByComparator<Group> orderByComparator) 883 throws com.liferay.portal.NoSuchGroupException { 884 return getPersistence() 885 .findByC_P_Last(companyId, parentGroupId, orderByComparator); 886 } 887 888 /** 889 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ?. 890 * 891 * @param companyId the company ID 892 * @param parentGroupId the parent group ID 893 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 894 * @return the last matching group, or <code>null</code> if a matching group could not be found 895 */ 896 public static Group fetchByC_P_Last(long companyId, long parentGroupId, 897 OrderByComparator<Group> orderByComparator) { 898 return getPersistence() 899 .fetchByC_P_Last(companyId, parentGroupId, orderByComparator); 900 } 901 902 /** 903 * Returns the groups before and after the current group in the ordered set where companyId = ? and parentGroupId = ?. 904 * 905 * @param groupId the primary key of the current group 906 * @param companyId the company ID 907 * @param parentGroupId the parent group ID 908 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 909 * @return the previous, current, and next group 910 * @throws NoSuchGroupException if a group with the primary key could not be found 911 */ 912 public static Group[] findByC_P_PrevAndNext(long groupId, long companyId, 913 long parentGroupId, OrderByComparator<Group> orderByComparator) 914 throws com.liferay.portal.NoSuchGroupException { 915 return getPersistence() 916 .findByC_P_PrevAndNext(groupId, companyId, parentGroupId, 917 orderByComparator); 918 } 919 920 /** 921 * Removes all the groups where companyId = ? and parentGroupId = ? from the database. 922 * 923 * @param companyId the company ID 924 * @param parentGroupId the parent group ID 925 */ 926 public static void removeByC_P(long companyId, long parentGroupId) { 927 getPersistence().removeByC_P(companyId, parentGroupId); 928 } 929 930 /** 931 * Returns the number of groups where companyId = ? and parentGroupId = ?. 932 * 933 * @param companyId the company ID 934 * @param parentGroupId the parent group ID 935 * @return the number of matching groups 936 */ 937 public static int countByC_P(long companyId, long parentGroupId) { 938 return getPersistence().countByC_P(companyId, parentGroupId); 939 } 940 941 /** 942 * Returns the group where companyId = ? and groupKey = ? or throws a {@link NoSuchGroupException} if it could not be found. 943 * 944 * @param companyId the company ID 945 * @param groupKey the group key 946 * @return the matching group 947 * @throws NoSuchGroupException if a matching group could not be found 948 */ 949 public static Group findByC_GK(long companyId, java.lang.String groupKey) 950 throws com.liferay.portal.NoSuchGroupException { 951 return getPersistence().findByC_GK(companyId, groupKey); 952 } 953 954 /** 955 * Returns the group where companyId = ? and groupKey = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 956 * 957 * @param companyId the company ID 958 * @param groupKey the group key 959 * @return the matching group, or <code>null</code> if a matching group could not be found 960 */ 961 public static Group fetchByC_GK(long companyId, java.lang.String groupKey) { 962 return getPersistence().fetchByC_GK(companyId, groupKey); 963 } 964 965 /** 966 * Returns the group where companyId = ? and groupKey = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 967 * 968 * @param companyId the company ID 969 * @param groupKey the group key 970 * @param retrieveFromCache whether to use the finder cache 971 * @return the matching group, or <code>null</code> if a matching group could not be found 972 */ 973 public static Group fetchByC_GK(long companyId, java.lang.String groupKey, 974 boolean retrieveFromCache) { 975 return getPersistence() 976 .fetchByC_GK(companyId, groupKey, retrieveFromCache); 977 } 978 979 /** 980 * Removes the group where companyId = ? and groupKey = ? from the database. 981 * 982 * @param companyId the company ID 983 * @param groupKey the group key 984 * @return the group that was removed 985 */ 986 public static Group removeByC_GK(long companyId, java.lang.String groupKey) 987 throws com.liferay.portal.NoSuchGroupException { 988 return getPersistence().removeByC_GK(companyId, groupKey); 989 } 990 991 /** 992 * Returns the number of groups where companyId = ? and groupKey = ?. 993 * 994 * @param companyId the company ID 995 * @param groupKey the group key 996 * @return the number of matching groups 997 */ 998 public static int countByC_GK(long companyId, java.lang.String groupKey) { 999 return getPersistence().countByC_GK(companyId, groupKey); 1000 } 1001 1002 /** 1003 * Returns the group where companyId = ? and friendlyURL = ? or throws a {@link NoSuchGroupException} if it could not be found. 1004 * 1005 * @param companyId the company ID 1006 * @param friendlyURL the friendly u r l 1007 * @return the matching group 1008 * @throws NoSuchGroupException if a matching group could not be found 1009 */ 1010 public static Group findByC_F(long companyId, java.lang.String friendlyURL) 1011 throws com.liferay.portal.NoSuchGroupException { 1012 return getPersistence().findByC_F(companyId, friendlyURL); 1013 } 1014 1015 /** 1016 * Returns the group where companyId = ? and friendlyURL = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1017 * 1018 * @param companyId the company ID 1019 * @param friendlyURL the friendly u r l 1020 * @return the matching group, or <code>null</code> if a matching group could not be found 1021 */ 1022 public static Group fetchByC_F(long companyId, java.lang.String friendlyURL) { 1023 return getPersistence().fetchByC_F(companyId, friendlyURL); 1024 } 1025 1026 /** 1027 * Returns the group where companyId = ? and friendlyURL = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1028 * 1029 * @param companyId the company ID 1030 * @param friendlyURL the friendly u r l 1031 * @param retrieveFromCache whether to use the finder cache 1032 * @return the matching group, or <code>null</code> if a matching group could not be found 1033 */ 1034 public static Group fetchByC_F(long companyId, 1035 java.lang.String friendlyURL, boolean retrieveFromCache) { 1036 return getPersistence() 1037 .fetchByC_F(companyId, friendlyURL, retrieveFromCache); 1038 } 1039 1040 /** 1041 * Removes the group where companyId = ? and friendlyURL = ? from the database. 1042 * 1043 * @param companyId the company ID 1044 * @param friendlyURL the friendly u r l 1045 * @return the group that was removed 1046 */ 1047 public static Group removeByC_F(long companyId, java.lang.String friendlyURL) 1048 throws com.liferay.portal.NoSuchGroupException { 1049 return getPersistence().removeByC_F(companyId, friendlyURL); 1050 } 1051 1052 /** 1053 * Returns the number of groups where companyId = ? and friendlyURL = ?. 1054 * 1055 * @param companyId the company ID 1056 * @param friendlyURL the friendly u r l 1057 * @return the number of matching groups 1058 */ 1059 public static int countByC_F(long companyId, java.lang.String friendlyURL) { 1060 return getPersistence().countByC_F(companyId, friendlyURL); 1061 } 1062 1063 /** 1064 * Returns all the groups where companyId = ? and site = ?. 1065 * 1066 * @param companyId the company ID 1067 * @param site the site 1068 * @return the matching groups 1069 */ 1070 public static List<Group> findByC_S(long companyId, boolean site) { 1071 return getPersistence().findByC_S(companyId, site); 1072 } 1073 1074 /** 1075 * Returns a range of all the groups where companyId = ? and site = ?. 1076 * 1077 * <p> 1078 * 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 GroupModelImpl}. 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. 1079 * </p> 1080 * 1081 * @param companyId the company ID 1082 * @param site the site 1083 * @param start the lower bound of the range of groups 1084 * @param end the upper bound of the range of groups (not inclusive) 1085 * @return the range of matching groups 1086 */ 1087 public static List<Group> findByC_S(long companyId, boolean site, 1088 int start, int end) { 1089 return getPersistence().findByC_S(companyId, site, start, end); 1090 } 1091 1092 /** 1093 * Returns an ordered range of all the groups where companyId = ? and site = ?. 1094 * 1095 * <p> 1096 * 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 GroupModelImpl}. 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. 1097 * </p> 1098 * 1099 * @param companyId the company ID 1100 * @param site the site 1101 * @param start the lower bound of the range of groups 1102 * @param end the upper bound of the range of groups (not inclusive) 1103 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1104 * @return the ordered range of matching groups 1105 */ 1106 public static List<Group> findByC_S(long companyId, boolean site, 1107 int start, int end, OrderByComparator<Group> orderByComparator) { 1108 return getPersistence() 1109 .findByC_S(companyId, site, start, end, orderByComparator); 1110 } 1111 1112 /** 1113 * Returns the first group in the ordered set where companyId = ? and site = ?. 1114 * 1115 * @param companyId the company ID 1116 * @param site the site 1117 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1118 * @return the first matching group 1119 * @throws NoSuchGroupException if a matching group could not be found 1120 */ 1121 public static Group findByC_S_First(long companyId, boolean site, 1122 OrderByComparator<Group> orderByComparator) 1123 throws com.liferay.portal.NoSuchGroupException { 1124 return getPersistence() 1125 .findByC_S_First(companyId, site, orderByComparator); 1126 } 1127 1128 /** 1129 * Returns the first group in the ordered set where companyId = ? and site = ?. 1130 * 1131 * @param companyId the company ID 1132 * @param site the site 1133 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1134 * @return the first matching group, or <code>null</code> if a matching group could not be found 1135 */ 1136 public static Group fetchByC_S_First(long companyId, boolean site, 1137 OrderByComparator<Group> orderByComparator) { 1138 return getPersistence() 1139 .fetchByC_S_First(companyId, site, orderByComparator); 1140 } 1141 1142 /** 1143 * Returns the last group in the ordered set where companyId = ? and site = ?. 1144 * 1145 * @param companyId the company ID 1146 * @param site the site 1147 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1148 * @return the last matching group 1149 * @throws NoSuchGroupException if a matching group could not be found 1150 */ 1151 public static Group findByC_S_Last(long companyId, boolean site, 1152 OrderByComparator<Group> orderByComparator) 1153 throws com.liferay.portal.NoSuchGroupException { 1154 return getPersistence() 1155 .findByC_S_Last(companyId, site, orderByComparator); 1156 } 1157 1158 /** 1159 * Returns the last group in the ordered set where companyId = ? and site = ?. 1160 * 1161 * @param companyId the company ID 1162 * @param site the site 1163 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1164 * @return the last matching group, or <code>null</code> if a matching group could not be found 1165 */ 1166 public static Group fetchByC_S_Last(long companyId, boolean site, 1167 OrderByComparator<Group> orderByComparator) { 1168 return getPersistence() 1169 .fetchByC_S_Last(companyId, site, orderByComparator); 1170 } 1171 1172 /** 1173 * Returns the groups before and after the current group in the ordered set where companyId = ? and site = ?. 1174 * 1175 * @param groupId the primary key of the current group 1176 * @param companyId the company ID 1177 * @param site the site 1178 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1179 * @return the previous, current, and next group 1180 * @throws NoSuchGroupException if a group with the primary key could not be found 1181 */ 1182 public static Group[] findByC_S_PrevAndNext(long groupId, long companyId, 1183 boolean site, OrderByComparator<Group> orderByComparator) 1184 throws com.liferay.portal.NoSuchGroupException { 1185 return getPersistence() 1186 .findByC_S_PrevAndNext(groupId, companyId, site, 1187 orderByComparator); 1188 } 1189 1190 /** 1191 * Removes all the groups where companyId = ? and site = ? from the database. 1192 * 1193 * @param companyId the company ID 1194 * @param site the site 1195 */ 1196 public static void removeByC_S(long companyId, boolean site) { 1197 getPersistence().removeByC_S(companyId, site); 1198 } 1199 1200 /** 1201 * Returns the number of groups where companyId = ? and site = ?. 1202 * 1203 * @param companyId the company ID 1204 * @param site the site 1205 * @return the number of matching groups 1206 */ 1207 public static int countByC_S(long companyId, boolean site) { 1208 return getPersistence().countByC_S(companyId, site); 1209 } 1210 1211 /** 1212 * Returns all the groups where type = ? and active = ?. 1213 * 1214 * @param type the type 1215 * @param active the active 1216 * @return the matching groups 1217 */ 1218 public static List<Group> findByT_A(int type, boolean active) { 1219 return getPersistence().findByT_A(type, active); 1220 } 1221 1222 /** 1223 * Returns a range of all the groups where type = ? and active = ?. 1224 * 1225 * <p> 1226 * 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 GroupModelImpl}. 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. 1227 * </p> 1228 * 1229 * @param type the type 1230 * @param active the active 1231 * @param start the lower bound of the range of groups 1232 * @param end the upper bound of the range of groups (not inclusive) 1233 * @return the range of matching groups 1234 */ 1235 public static List<Group> findByT_A(int type, boolean active, int start, 1236 int end) { 1237 return getPersistence().findByT_A(type, active, start, end); 1238 } 1239 1240 /** 1241 * Returns an ordered range of all the groups where type = ? and active = ?. 1242 * 1243 * <p> 1244 * 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 GroupModelImpl}. 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. 1245 * </p> 1246 * 1247 * @param type the type 1248 * @param active the active 1249 * @param start the lower bound of the range of groups 1250 * @param end the upper bound of the range of groups (not inclusive) 1251 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1252 * @return the ordered range of matching groups 1253 */ 1254 public static List<Group> findByT_A(int type, boolean active, int start, 1255 int end, OrderByComparator<Group> orderByComparator) { 1256 return getPersistence() 1257 .findByT_A(type, active, start, end, orderByComparator); 1258 } 1259 1260 /** 1261 * Returns the first group in the ordered set where type = ? and active = ?. 1262 * 1263 * @param type the type 1264 * @param active the active 1265 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1266 * @return the first matching group 1267 * @throws NoSuchGroupException if a matching group could not be found 1268 */ 1269 public static Group findByT_A_First(int type, boolean active, 1270 OrderByComparator<Group> orderByComparator) 1271 throws com.liferay.portal.NoSuchGroupException { 1272 return getPersistence().findByT_A_First(type, active, orderByComparator); 1273 } 1274 1275 /** 1276 * Returns the first group in the ordered set where type = ? and active = ?. 1277 * 1278 * @param type the type 1279 * @param active the active 1280 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1281 * @return the first matching group, or <code>null</code> if a matching group could not be found 1282 */ 1283 public static Group fetchByT_A_First(int type, boolean active, 1284 OrderByComparator<Group> orderByComparator) { 1285 return getPersistence().fetchByT_A_First(type, active, orderByComparator); 1286 } 1287 1288 /** 1289 * Returns the last group in the ordered set where type = ? and active = ?. 1290 * 1291 * @param type the type 1292 * @param active the active 1293 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1294 * @return the last matching group 1295 * @throws NoSuchGroupException if a matching group could not be found 1296 */ 1297 public static Group findByT_A_Last(int type, boolean active, 1298 OrderByComparator<Group> orderByComparator) 1299 throws com.liferay.portal.NoSuchGroupException { 1300 return getPersistence().findByT_A_Last(type, active, orderByComparator); 1301 } 1302 1303 /** 1304 * Returns the last group in the ordered set where type = ? and active = ?. 1305 * 1306 * @param type the type 1307 * @param active the active 1308 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1309 * @return the last matching group, or <code>null</code> if a matching group could not be found 1310 */ 1311 public static Group fetchByT_A_Last(int type, boolean active, 1312 OrderByComparator<Group> orderByComparator) { 1313 return getPersistence().fetchByT_A_Last(type, active, orderByComparator); 1314 } 1315 1316 /** 1317 * Returns the groups before and after the current group in the ordered set where type = ? and active = ?. 1318 * 1319 * @param groupId the primary key of the current group 1320 * @param type the type 1321 * @param active the active 1322 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1323 * @return the previous, current, and next group 1324 * @throws NoSuchGroupException if a group with the primary key could not be found 1325 */ 1326 public static Group[] findByT_A_PrevAndNext(long groupId, int type, 1327 boolean active, OrderByComparator<Group> orderByComparator) 1328 throws com.liferay.portal.NoSuchGroupException { 1329 return getPersistence() 1330 .findByT_A_PrevAndNext(groupId, type, active, 1331 orderByComparator); 1332 } 1333 1334 /** 1335 * Removes all the groups where type = ? and active = ? from the database. 1336 * 1337 * @param type the type 1338 * @param active the active 1339 */ 1340 public static void removeByT_A(int type, boolean active) { 1341 getPersistence().removeByT_A(type, active); 1342 } 1343 1344 /** 1345 * Returns the number of groups where type = ? and active = ?. 1346 * 1347 * @param type the type 1348 * @param active the active 1349 * @return the number of matching groups 1350 */ 1351 public static int countByT_A(int type, boolean active) { 1352 return getPersistence().countByT_A(type, active); 1353 } 1354 1355 /** 1356 * Returns all the groups where groupId > ? and companyId = ? and parentGroupId = ?. 1357 * 1358 * @param groupId the group ID 1359 * @param companyId the company ID 1360 * @param parentGroupId the parent group ID 1361 * @return the matching groups 1362 */ 1363 public static List<Group> findByG_C_P(long groupId, long companyId, 1364 long parentGroupId) { 1365 return getPersistence().findByG_C_P(groupId, companyId, parentGroupId); 1366 } 1367 1368 /** 1369 * Returns a range of all the groups where groupId > ? and companyId = ? and parentGroupId = ?. 1370 * 1371 * <p> 1372 * 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 GroupModelImpl}. 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. 1373 * </p> 1374 * 1375 * @param groupId the group ID 1376 * @param companyId the company ID 1377 * @param parentGroupId the parent group ID 1378 * @param start the lower bound of the range of groups 1379 * @param end the upper bound of the range of groups (not inclusive) 1380 * @return the range of matching groups 1381 */ 1382 public static List<Group> findByG_C_P(long groupId, long companyId, 1383 long parentGroupId, int start, int end) { 1384 return getPersistence() 1385 .findByG_C_P(groupId, companyId, parentGroupId, start, end); 1386 } 1387 1388 /** 1389 * Returns an ordered range of all the groups where groupId > ? and companyId = ? and parentGroupId = ?. 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 GroupModelImpl}. 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 groupId the group ID 1396 * @param companyId the company ID 1397 * @param parentGroupId the parent group ID 1398 * @param start the lower bound of the range of groups 1399 * @param end the upper bound of the range of groups (not inclusive) 1400 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1401 * @return the ordered range of matching groups 1402 */ 1403 public static List<Group> findByG_C_P(long groupId, long companyId, 1404 long parentGroupId, int start, int end, 1405 OrderByComparator<Group> orderByComparator) { 1406 return getPersistence() 1407 .findByG_C_P(groupId, companyId, parentGroupId, start, end, 1408 orderByComparator); 1409 } 1410 1411 /** 1412 * Returns the first group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1413 * 1414 * @param groupId the group ID 1415 * @param companyId the company ID 1416 * @param parentGroupId the parent group ID 1417 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1418 * @return the first matching group 1419 * @throws NoSuchGroupException if a matching group could not be found 1420 */ 1421 public static Group findByG_C_P_First(long groupId, long companyId, 1422 long parentGroupId, OrderByComparator<Group> orderByComparator) 1423 throws com.liferay.portal.NoSuchGroupException { 1424 return getPersistence() 1425 .findByG_C_P_First(groupId, companyId, parentGroupId, 1426 orderByComparator); 1427 } 1428 1429 /** 1430 * Returns the first group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1431 * 1432 * @param groupId the group ID 1433 * @param companyId the company ID 1434 * @param parentGroupId the parent group ID 1435 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1436 * @return the first matching group, or <code>null</code> if a matching group could not be found 1437 */ 1438 public static Group fetchByG_C_P_First(long groupId, long companyId, 1439 long parentGroupId, OrderByComparator<Group> orderByComparator) { 1440 return getPersistence() 1441 .fetchByG_C_P_First(groupId, companyId, parentGroupId, 1442 orderByComparator); 1443 } 1444 1445 /** 1446 * Returns the last group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1447 * 1448 * @param groupId the group ID 1449 * @param companyId the company ID 1450 * @param parentGroupId the parent group ID 1451 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1452 * @return the last matching group 1453 * @throws NoSuchGroupException if a matching group could not be found 1454 */ 1455 public static Group findByG_C_P_Last(long groupId, long companyId, 1456 long parentGroupId, OrderByComparator<Group> orderByComparator) 1457 throws com.liferay.portal.NoSuchGroupException { 1458 return getPersistence() 1459 .findByG_C_P_Last(groupId, companyId, parentGroupId, 1460 orderByComparator); 1461 } 1462 1463 /** 1464 * Returns the last group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1465 * 1466 * @param groupId the group ID 1467 * @param companyId the company ID 1468 * @param parentGroupId the parent group ID 1469 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1470 * @return the last matching group, or <code>null</code> if a matching group could not be found 1471 */ 1472 public static Group fetchByG_C_P_Last(long groupId, long companyId, 1473 long parentGroupId, OrderByComparator<Group> orderByComparator) { 1474 return getPersistence() 1475 .fetchByG_C_P_Last(groupId, companyId, parentGroupId, 1476 orderByComparator); 1477 } 1478 1479 /** 1480 * Removes all the groups where groupId > ? and companyId = ? and parentGroupId = ? from the database. 1481 * 1482 * @param groupId the group ID 1483 * @param companyId the company ID 1484 * @param parentGroupId the parent group ID 1485 */ 1486 public static void removeByG_C_P(long groupId, long companyId, 1487 long parentGroupId) { 1488 getPersistence().removeByG_C_P(groupId, companyId, parentGroupId); 1489 } 1490 1491 /** 1492 * Returns the number of groups where groupId > ? and companyId = ? and parentGroupId = ?. 1493 * 1494 * @param groupId the group ID 1495 * @param companyId the company ID 1496 * @param parentGroupId the parent group ID 1497 * @return the number of matching groups 1498 */ 1499 public static int countByG_C_P(long groupId, long companyId, 1500 long parentGroupId) { 1501 return getPersistence().countByG_C_P(groupId, companyId, parentGroupId); 1502 } 1503 1504 /** 1505 * Returns the group where companyId = ? and classNameId = ? and classPK = ? or throws a {@link NoSuchGroupException} if it could not be found. 1506 * 1507 * @param companyId the company ID 1508 * @param classNameId the class name ID 1509 * @param classPK the class p k 1510 * @return the matching group 1511 * @throws NoSuchGroupException if a matching group could not be found 1512 */ 1513 public static Group findByC_C_C(long companyId, long classNameId, 1514 long classPK) throws com.liferay.portal.NoSuchGroupException { 1515 return getPersistence().findByC_C_C(companyId, classNameId, classPK); 1516 } 1517 1518 /** 1519 * Returns the group where companyId = ? and classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1520 * 1521 * @param companyId the company ID 1522 * @param classNameId the class name ID 1523 * @param classPK the class p k 1524 * @return the matching group, or <code>null</code> if a matching group could not be found 1525 */ 1526 public static Group fetchByC_C_C(long companyId, long classNameId, 1527 long classPK) { 1528 return getPersistence().fetchByC_C_C(companyId, classNameId, classPK); 1529 } 1530 1531 /** 1532 * Returns the group where companyId = ? and classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1533 * 1534 * @param companyId the company ID 1535 * @param classNameId the class name ID 1536 * @param classPK the class p k 1537 * @param retrieveFromCache whether to use the finder cache 1538 * @return the matching group, or <code>null</code> if a matching group could not be found 1539 */ 1540 public static Group fetchByC_C_C(long companyId, long classNameId, 1541 long classPK, boolean retrieveFromCache) { 1542 return getPersistence() 1543 .fetchByC_C_C(companyId, classNameId, classPK, 1544 retrieveFromCache); 1545 } 1546 1547 /** 1548 * Removes the group where companyId = ? and classNameId = ? and classPK = ? from the database. 1549 * 1550 * @param companyId the company ID 1551 * @param classNameId the class name ID 1552 * @param classPK the class p k 1553 * @return the group that was removed 1554 */ 1555 public static Group removeByC_C_C(long companyId, long classNameId, 1556 long classPK) throws com.liferay.portal.NoSuchGroupException { 1557 return getPersistence().removeByC_C_C(companyId, classNameId, classPK); 1558 } 1559 1560 /** 1561 * Returns the number of groups where companyId = ? and classNameId = ? and classPK = ?. 1562 * 1563 * @param companyId the company ID 1564 * @param classNameId the class name ID 1565 * @param classPK the class p k 1566 * @return the number of matching groups 1567 */ 1568 public static int countByC_C_C(long companyId, long classNameId, 1569 long classPK) { 1570 return getPersistence().countByC_C_C(companyId, classNameId, classPK); 1571 } 1572 1573 /** 1574 * Returns all the groups where companyId = ? and classNameId = ? and parentGroupId = ?. 1575 * 1576 * @param companyId the company ID 1577 * @param classNameId the class name ID 1578 * @param parentGroupId the parent group ID 1579 * @return the matching groups 1580 */ 1581 public static List<Group> findByC_C_P(long companyId, long classNameId, 1582 long parentGroupId) { 1583 return getPersistence() 1584 .findByC_C_P(companyId, classNameId, parentGroupId); 1585 } 1586 1587 /** 1588 * Returns a range of all the groups where companyId = ? and classNameId = ? and parentGroupId = ?. 1589 * 1590 * <p> 1591 * 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 GroupModelImpl}. 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. 1592 * </p> 1593 * 1594 * @param companyId the company ID 1595 * @param classNameId the class name ID 1596 * @param parentGroupId the parent group ID 1597 * @param start the lower bound of the range of groups 1598 * @param end the upper bound of the range of groups (not inclusive) 1599 * @return the range of matching groups 1600 */ 1601 public static List<Group> findByC_C_P(long companyId, long classNameId, 1602 long parentGroupId, int start, int end) { 1603 return getPersistence() 1604 .findByC_C_P(companyId, classNameId, parentGroupId, start, 1605 end); 1606 } 1607 1608 /** 1609 * Returns an ordered range of all the groups where companyId = ? and classNameId = ? and parentGroupId = ?. 1610 * 1611 * <p> 1612 * 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 GroupModelImpl}. 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. 1613 * </p> 1614 * 1615 * @param companyId the company ID 1616 * @param classNameId the class name ID 1617 * @param parentGroupId the parent group ID 1618 * @param start the lower bound of the range of groups 1619 * @param end the upper bound of the range of groups (not inclusive) 1620 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1621 * @return the ordered range of matching groups 1622 */ 1623 public static List<Group> findByC_C_P(long companyId, long classNameId, 1624 long parentGroupId, int start, int end, 1625 OrderByComparator<Group> orderByComparator) { 1626 return getPersistence() 1627 .findByC_C_P(companyId, classNameId, parentGroupId, start, 1628 end, orderByComparator); 1629 } 1630 1631 /** 1632 * Returns the first group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 1633 * 1634 * @param companyId the company ID 1635 * @param classNameId the class name ID 1636 * @param parentGroupId the parent group ID 1637 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1638 * @return the first matching group 1639 * @throws NoSuchGroupException if a matching group could not be found 1640 */ 1641 public static Group findByC_C_P_First(long companyId, long classNameId, 1642 long parentGroupId, OrderByComparator<Group> orderByComparator) 1643 throws com.liferay.portal.NoSuchGroupException { 1644 return getPersistence() 1645 .findByC_C_P_First(companyId, classNameId, parentGroupId, 1646 orderByComparator); 1647 } 1648 1649 /** 1650 * Returns the first group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 1651 * 1652 * @param companyId the company ID 1653 * @param classNameId the class name ID 1654 * @param parentGroupId the parent group ID 1655 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1656 * @return the first matching group, or <code>null</code> if a matching group could not be found 1657 */ 1658 public static Group fetchByC_C_P_First(long companyId, long classNameId, 1659 long parentGroupId, OrderByComparator<Group> orderByComparator) { 1660 return getPersistence() 1661 .fetchByC_C_P_First(companyId, classNameId, parentGroupId, 1662 orderByComparator); 1663 } 1664 1665 /** 1666 * Returns the last group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 1667 * 1668 * @param companyId the company ID 1669 * @param classNameId the class name ID 1670 * @param parentGroupId the parent group ID 1671 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1672 * @return the last matching group 1673 * @throws NoSuchGroupException if a matching group could not be found 1674 */ 1675 public static Group findByC_C_P_Last(long companyId, long classNameId, 1676 long parentGroupId, OrderByComparator<Group> orderByComparator) 1677 throws com.liferay.portal.NoSuchGroupException { 1678 return getPersistence() 1679 .findByC_C_P_Last(companyId, classNameId, parentGroupId, 1680 orderByComparator); 1681 } 1682 1683 /** 1684 * Returns the last group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 1685 * 1686 * @param companyId the company ID 1687 * @param classNameId the class name ID 1688 * @param parentGroupId the parent group ID 1689 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1690 * @return the last matching group, or <code>null</code> if a matching group could not be found 1691 */ 1692 public static Group fetchByC_C_P_Last(long companyId, long classNameId, 1693 long parentGroupId, OrderByComparator<Group> orderByComparator) { 1694 return getPersistence() 1695 .fetchByC_C_P_Last(companyId, classNameId, parentGroupId, 1696 orderByComparator); 1697 } 1698 1699 /** 1700 * Returns the groups before and after the current group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 1701 * 1702 * @param groupId the primary key of the current group 1703 * @param companyId the company ID 1704 * @param classNameId the class name ID 1705 * @param parentGroupId the parent group ID 1706 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1707 * @return the previous, current, and next group 1708 * @throws NoSuchGroupException if a group with the primary key could not be found 1709 */ 1710 public static Group[] findByC_C_P_PrevAndNext(long groupId, long companyId, 1711 long classNameId, long parentGroupId, 1712 OrderByComparator<Group> orderByComparator) 1713 throws com.liferay.portal.NoSuchGroupException { 1714 return getPersistence() 1715 .findByC_C_P_PrevAndNext(groupId, companyId, classNameId, 1716 parentGroupId, orderByComparator); 1717 } 1718 1719 /** 1720 * Removes all the groups where companyId = ? and classNameId = ? and parentGroupId = ? from the database. 1721 * 1722 * @param companyId the company ID 1723 * @param classNameId the class name ID 1724 * @param parentGroupId the parent group ID 1725 */ 1726 public static void removeByC_C_P(long companyId, long classNameId, 1727 long parentGroupId) { 1728 getPersistence().removeByC_C_P(companyId, classNameId, parentGroupId); 1729 } 1730 1731 /** 1732 * Returns the number of groups where companyId = ? and classNameId = ? and parentGroupId = ?. 1733 * 1734 * @param companyId the company ID 1735 * @param classNameId the class name ID 1736 * @param parentGroupId the parent group ID 1737 * @return the number of matching groups 1738 */ 1739 public static int countByC_C_P(long companyId, long classNameId, 1740 long parentGroupId) { 1741 return getPersistence() 1742 .countByC_C_P(companyId, classNameId, parentGroupId); 1743 } 1744 1745 /** 1746 * Returns all the groups where companyId = ? and parentGroupId = ? and site = ?. 1747 * 1748 * @param companyId the company ID 1749 * @param parentGroupId the parent group ID 1750 * @param site the site 1751 * @return the matching groups 1752 */ 1753 public static List<Group> findByC_P_S(long companyId, long parentGroupId, 1754 boolean site) { 1755 return getPersistence().findByC_P_S(companyId, parentGroupId, site); 1756 } 1757 1758 /** 1759 * Returns a range of all the groups where companyId = ? and parentGroupId = ? and site = ?. 1760 * 1761 * <p> 1762 * 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 GroupModelImpl}. 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. 1763 * </p> 1764 * 1765 * @param companyId the company ID 1766 * @param parentGroupId the parent group ID 1767 * @param site the site 1768 * @param start the lower bound of the range of groups 1769 * @param end the upper bound of the range of groups (not inclusive) 1770 * @return the range of matching groups 1771 */ 1772 public static List<Group> findByC_P_S(long companyId, long parentGroupId, 1773 boolean site, int start, int end) { 1774 return getPersistence() 1775 .findByC_P_S(companyId, parentGroupId, site, start, end); 1776 } 1777 1778 /** 1779 * Returns an ordered range of all the groups where companyId = ? and parentGroupId = ? and site = ?. 1780 * 1781 * <p> 1782 * 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 GroupModelImpl}. 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. 1783 * </p> 1784 * 1785 * @param companyId the company ID 1786 * @param parentGroupId the parent group ID 1787 * @param site the site 1788 * @param start the lower bound of the range of groups 1789 * @param end the upper bound of the range of groups (not inclusive) 1790 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1791 * @return the ordered range of matching groups 1792 */ 1793 public static List<Group> findByC_P_S(long companyId, long parentGroupId, 1794 boolean site, int start, int end, 1795 OrderByComparator<Group> orderByComparator) { 1796 return getPersistence() 1797 .findByC_P_S(companyId, parentGroupId, site, start, end, 1798 orderByComparator); 1799 } 1800 1801 /** 1802 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 1803 * 1804 * @param companyId the company ID 1805 * @param parentGroupId the parent group ID 1806 * @param site the site 1807 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1808 * @return the first matching group 1809 * @throws NoSuchGroupException if a matching group could not be found 1810 */ 1811 public static Group findByC_P_S_First(long companyId, long parentGroupId, 1812 boolean site, OrderByComparator<Group> orderByComparator) 1813 throws com.liferay.portal.NoSuchGroupException { 1814 return getPersistence() 1815 .findByC_P_S_First(companyId, parentGroupId, site, 1816 orderByComparator); 1817 } 1818 1819 /** 1820 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 1821 * 1822 * @param companyId the company ID 1823 * @param parentGroupId the parent group ID 1824 * @param site the site 1825 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1826 * @return the first matching group, or <code>null</code> if a matching group could not be found 1827 */ 1828 public static Group fetchByC_P_S_First(long companyId, long parentGroupId, 1829 boolean site, OrderByComparator<Group> orderByComparator) { 1830 return getPersistence() 1831 .fetchByC_P_S_First(companyId, parentGroupId, site, 1832 orderByComparator); 1833 } 1834 1835 /** 1836 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 1837 * 1838 * @param companyId the company ID 1839 * @param parentGroupId the parent group ID 1840 * @param site the site 1841 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1842 * @return the last matching group 1843 * @throws NoSuchGroupException if a matching group could not be found 1844 */ 1845 public static Group findByC_P_S_Last(long companyId, long parentGroupId, 1846 boolean site, OrderByComparator<Group> orderByComparator) 1847 throws com.liferay.portal.NoSuchGroupException { 1848 return getPersistence() 1849 .findByC_P_S_Last(companyId, parentGroupId, site, 1850 orderByComparator); 1851 } 1852 1853 /** 1854 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 1855 * 1856 * @param companyId the company ID 1857 * @param parentGroupId the parent group ID 1858 * @param site the site 1859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1860 * @return the last matching group, or <code>null</code> if a matching group could not be found 1861 */ 1862 public static Group fetchByC_P_S_Last(long companyId, long parentGroupId, 1863 boolean site, OrderByComparator<Group> orderByComparator) { 1864 return getPersistence() 1865 .fetchByC_P_S_Last(companyId, parentGroupId, site, 1866 orderByComparator); 1867 } 1868 1869 /** 1870 * Returns the groups before and after the current group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 1871 * 1872 * @param groupId the primary key of the current group 1873 * @param companyId the company ID 1874 * @param parentGroupId the parent group ID 1875 * @param site the site 1876 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1877 * @return the previous, current, and next group 1878 * @throws NoSuchGroupException if a group with the primary key could not be found 1879 */ 1880 public static Group[] findByC_P_S_PrevAndNext(long groupId, long companyId, 1881 long parentGroupId, boolean site, 1882 OrderByComparator<Group> orderByComparator) 1883 throws com.liferay.portal.NoSuchGroupException { 1884 return getPersistence() 1885 .findByC_P_S_PrevAndNext(groupId, companyId, parentGroupId, 1886 site, orderByComparator); 1887 } 1888 1889 /** 1890 * Removes all the groups where companyId = ? and parentGroupId = ? and site = ? from the database. 1891 * 1892 * @param companyId the company ID 1893 * @param parentGroupId the parent group ID 1894 * @param site the site 1895 */ 1896 public static void removeByC_P_S(long companyId, long parentGroupId, 1897 boolean site) { 1898 getPersistence().removeByC_P_S(companyId, parentGroupId, site); 1899 } 1900 1901 /** 1902 * Returns the number of groups where companyId = ? and parentGroupId = ? and site = ?. 1903 * 1904 * @param companyId the company ID 1905 * @param parentGroupId the parent group ID 1906 * @param site the site 1907 * @return the number of matching groups 1908 */ 1909 public static int countByC_P_S(long companyId, long parentGroupId, 1910 boolean site) { 1911 return getPersistence().countByC_P_S(companyId, parentGroupId, site); 1912 } 1913 1914 /** 1915 * Returns the group where companyId = ? and liveGroupId = ? and groupKey = ? or throws a {@link NoSuchGroupException} if it could not be found. 1916 * 1917 * @param companyId the company ID 1918 * @param liveGroupId the live group ID 1919 * @param groupKey the group key 1920 * @return the matching group 1921 * @throws NoSuchGroupException if a matching group could not be found 1922 */ 1923 public static Group findByC_L_GK(long companyId, long liveGroupId, 1924 java.lang.String groupKey) 1925 throws com.liferay.portal.NoSuchGroupException { 1926 return getPersistence().findByC_L_GK(companyId, liveGroupId, groupKey); 1927 } 1928 1929 /** 1930 * Returns the group where companyId = ? and liveGroupId = ? and groupKey = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1931 * 1932 * @param companyId the company ID 1933 * @param liveGroupId the live group ID 1934 * @param groupKey the group key 1935 * @return the matching group, or <code>null</code> if a matching group could not be found 1936 */ 1937 public static Group fetchByC_L_GK(long companyId, long liveGroupId, 1938 java.lang.String groupKey) { 1939 return getPersistence().fetchByC_L_GK(companyId, liveGroupId, groupKey); 1940 } 1941 1942 /** 1943 * Returns the group where companyId = ? and liveGroupId = ? and groupKey = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1944 * 1945 * @param companyId the company ID 1946 * @param liveGroupId the live group ID 1947 * @param groupKey the group key 1948 * @param retrieveFromCache whether to use the finder cache 1949 * @return the matching group, or <code>null</code> if a matching group could not be found 1950 */ 1951 public static Group fetchByC_L_GK(long companyId, long liveGroupId, 1952 java.lang.String groupKey, boolean retrieveFromCache) { 1953 return getPersistence() 1954 .fetchByC_L_GK(companyId, liveGroupId, groupKey, 1955 retrieveFromCache); 1956 } 1957 1958 /** 1959 * Removes the group where companyId = ? and liveGroupId = ? and groupKey = ? from the database. 1960 * 1961 * @param companyId the company ID 1962 * @param liveGroupId the live group ID 1963 * @param groupKey the group key 1964 * @return the group that was removed 1965 */ 1966 public static Group removeByC_L_GK(long companyId, long liveGroupId, 1967 java.lang.String groupKey) 1968 throws com.liferay.portal.NoSuchGroupException { 1969 return getPersistence().removeByC_L_GK(companyId, liveGroupId, groupKey); 1970 } 1971 1972 /** 1973 * Returns the number of groups where companyId = ? and liveGroupId = ? and groupKey = ?. 1974 * 1975 * @param companyId the company ID 1976 * @param liveGroupId the live group ID 1977 * @param groupKey the group key 1978 * @return the number of matching groups 1979 */ 1980 public static int countByC_L_GK(long companyId, long liveGroupId, 1981 java.lang.String groupKey) { 1982 return getPersistence().countByC_L_GK(companyId, liveGroupId, groupKey); 1983 } 1984 1985 /** 1986 * Returns the group where companyId = ? and classNameId = ? and liveGroupId = ? and groupKey = ? or throws a {@link NoSuchGroupException} if it could not be found. 1987 * 1988 * @param companyId the company ID 1989 * @param classNameId the class name ID 1990 * @param liveGroupId the live group ID 1991 * @param groupKey the group key 1992 * @return the matching group 1993 * @throws NoSuchGroupException if a matching group could not be found 1994 */ 1995 public static Group findByC_C_L_GK(long companyId, long classNameId, 1996 long liveGroupId, java.lang.String groupKey) 1997 throws com.liferay.portal.NoSuchGroupException { 1998 return getPersistence() 1999 .findByC_C_L_GK(companyId, classNameId, liveGroupId, groupKey); 2000 } 2001 2002 /** 2003 * Returns the group where companyId = ? and classNameId = ? and liveGroupId = ? and groupKey = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2004 * 2005 * @param companyId the company ID 2006 * @param classNameId the class name ID 2007 * @param liveGroupId the live group ID 2008 * @param groupKey the group key 2009 * @return the matching group, or <code>null</code> if a matching group could not be found 2010 */ 2011 public static Group fetchByC_C_L_GK(long companyId, long classNameId, 2012 long liveGroupId, java.lang.String groupKey) { 2013 return getPersistence() 2014 .fetchByC_C_L_GK(companyId, classNameId, liveGroupId, 2015 groupKey); 2016 } 2017 2018 /** 2019 * Returns the group where companyId = ? and classNameId = ? and liveGroupId = ? and groupKey = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2020 * 2021 * @param companyId the company ID 2022 * @param classNameId the class name ID 2023 * @param liveGroupId the live group ID 2024 * @param groupKey the group key 2025 * @param retrieveFromCache whether to use the finder cache 2026 * @return the matching group, or <code>null</code> if a matching group could not be found 2027 */ 2028 public static Group fetchByC_C_L_GK(long companyId, long classNameId, 2029 long liveGroupId, java.lang.String groupKey, boolean retrieveFromCache) { 2030 return getPersistence() 2031 .fetchByC_C_L_GK(companyId, classNameId, liveGroupId, 2032 groupKey, retrieveFromCache); 2033 } 2034 2035 /** 2036 * Removes the group where companyId = ? and classNameId = ? and liveGroupId = ? and groupKey = ? from the database. 2037 * 2038 * @param companyId the company ID 2039 * @param classNameId the class name ID 2040 * @param liveGroupId the live group ID 2041 * @param groupKey the group key 2042 * @return the group that was removed 2043 */ 2044 public static Group removeByC_C_L_GK(long companyId, long classNameId, 2045 long liveGroupId, java.lang.String groupKey) 2046 throws com.liferay.portal.NoSuchGroupException { 2047 return getPersistence() 2048 .removeByC_C_L_GK(companyId, classNameId, liveGroupId, 2049 groupKey); 2050 } 2051 2052 /** 2053 * Returns the number of groups where companyId = ? and classNameId = ? and liveGroupId = ? and groupKey = ?. 2054 * 2055 * @param companyId the company ID 2056 * @param classNameId the class name ID 2057 * @param liveGroupId the live group ID 2058 * @param groupKey the group key 2059 * @return the number of matching groups 2060 */ 2061 public static int countByC_C_L_GK(long companyId, long classNameId, 2062 long liveGroupId, java.lang.String groupKey) { 2063 return getPersistence() 2064 .countByC_C_L_GK(companyId, classNameId, liveGroupId, 2065 groupKey); 2066 } 2067 2068 /** 2069 * Returns all the groups where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2070 * 2071 * @param companyId the company ID 2072 * @param parentGroupId the parent group ID 2073 * @param site the site 2074 * @param inheritContent the inherit content 2075 * @return the matching groups 2076 */ 2077 public static List<Group> findByC_P_S_I(long companyId, long parentGroupId, 2078 boolean site, boolean inheritContent) { 2079 return getPersistence() 2080 .findByC_P_S_I(companyId, parentGroupId, site, inheritContent); 2081 } 2082 2083 /** 2084 * Returns a range of all the groups where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 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 GroupModelImpl}. 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 companyId the company ID 2091 * @param parentGroupId the parent group ID 2092 * @param site the site 2093 * @param inheritContent the inherit content 2094 * @param start the lower bound of the range of groups 2095 * @param end the upper bound of the range of groups (not inclusive) 2096 * @return the range of matching groups 2097 */ 2098 public static List<Group> findByC_P_S_I(long companyId, long parentGroupId, 2099 boolean site, boolean inheritContent, int start, int end) { 2100 return getPersistence() 2101 .findByC_P_S_I(companyId, parentGroupId, site, 2102 inheritContent, start, end); 2103 } 2104 2105 /** 2106 * Returns an ordered range of all the groups where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2107 * 2108 * <p> 2109 * 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 GroupModelImpl}. 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. 2110 * </p> 2111 * 2112 * @param companyId the company ID 2113 * @param parentGroupId the parent group ID 2114 * @param site the site 2115 * @param inheritContent the inherit content 2116 * @param start the lower bound of the range of groups 2117 * @param end the upper bound of the range of groups (not inclusive) 2118 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2119 * @return the ordered range of matching groups 2120 */ 2121 public static List<Group> findByC_P_S_I(long companyId, long parentGroupId, 2122 boolean site, boolean inheritContent, int start, int end, 2123 OrderByComparator<Group> orderByComparator) { 2124 return getPersistence() 2125 .findByC_P_S_I(companyId, parentGroupId, site, 2126 inheritContent, start, end, orderByComparator); 2127 } 2128 2129 /** 2130 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2131 * 2132 * @param companyId the company ID 2133 * @param parentGroupId the parent group ID 2134 * @param site the site 2135 * @param inheritContent the inherit content 2136 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2137 * @return the first matching group 2138 * @throws NoSuchGroupException if a matching group could not be found 2139 */ 2140 public static Group findByC_P_S_I_First(long companyId, long parentGroupId, 2141 boolean site, boolean inheritContent, 2142 OrderByComparator<Group> orderByComparator) 2143 throws com.liferay.portal.NoSuchGroupException { 2144 return getPersistence() 2145 .findByC_P_S_I_First(companyId, parentGroupId, site, 2146 inheritContent, orderByComparator); 2147 } 2148 2149 /** 2150 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2151 * 2152 * @param companyId the company ID 2153 * @param parentGroupId the parent group ID 2154 * @param site the site 2155 * @param inheritContent the inherit content 2156 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2157 * @return the first matching group, or <code>null</code> if a matching group could not be found 2158 */ 2159 public static Group fetchByC_P_S_I_First(long companyId, 2160 long parentGroupId, boolean site, boolean inheritContent, 2161 OrderByComparator<Group> orderByComparator) { 2162 return getPersistence() 2163 .fetchByC_P_S_I_First(companyId, parentGroupId, site, 2164 inheritContent, orderByComparator); 2165 } 2166 2167 /** 2168 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2169 * 2170 * @param companyId the company ID 2171 * @param parentGroupId the parent group ID 2172 * @param site the site 2173 * @param inheritContent the inherit content 2174 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2175 * @return the last matching group 2176 * @throws NoSuchGroupException if a matching group could not be found 2177 */ 2178 public static Group findByC_P_S_I_Last(long companyId, long parentGroupId, 2179 boolean site, boolean inheritContent, 2180 OrderByComparator<Group> orderByComparator) 2181 throws com.liferay.portal.NoSuchGroupException { 2182 return getPersistence() 2183 .findByC_P_S_I_Last(companyId, parentGroupId, site, 2184 inheritContent, orderByComparator); 2185 } 2186 2187 /** 2188 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2189 * 2190 * @param companyId the company ID 2191 * @param parentGroupId the parent group ID 2192 * @param site the site 2193 * @param inheritContent the inherit content 2194 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2195 * @return the last matching group, or <code>null</code> if a matching group could not be found 2196 */ 2197 public static Group fetchByC_P_S_I_Last(long companyId, long parentGroupId, 2198 boolean site, boolean inheritContent, 2199 OrderByComparator<Group> orderByComparator) { 2200 return getPersistence() 2201 .fetchByC_P_S_I_Last(companyId, parentGroupId, site, 2202 inheritContent, orderByComparator); 2203 } 2204 2205 /** 2206 * Returns the groups before and after the current group in the ordered set where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2207 * 2208 * @param groupId the primary key of the current group 2209 * @param companyId the company ID 2210 * @param parentGroupId the parent group ID 2211 * @param site the site 2212 * @param inheritContent the inherit content 2213 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2214 * @return the previous, current, and next group 2215 * @throws NoSuchGroupException if a group with the primary key could not be found 2216 */ 2217 public static Group[] findByC_P_S_I_PrevAndNext(long groupId, 2218 long companyId, long parentGroupId, boolean site, 2219 boolean inheritContent, OrderByComparator<Group> orderByComparator) 2220 throws com.liferay.portal.NoSuchGroupException { 2221 return getPersistence() 2222 .findByC_P_S_I_PrevAndNext(groupId, companyId, 2223 parentGroupId, site, inheritContent, orderByComparator); 2224 } 2225 2226 /** 2227 * Removes all the groups where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ? from the database. 2228 * 2229 * @param companyId the company ID 2230 * @param parentGroupId the parent group ID 2231 * @param site the site 2232 * @param inheritContent the inherit content 2233 */ 2234 public static void removeByC_P_S_I(long companyId, long parentGroupId, 2235 boolean site, boolean inheritContent) { 2236 getPersistence() 2237 .removeByC_P_S_I(companyId, parentGroupId, site, inheritContent); 2238 } 2239 2240 /** 2241 * Returns the number of groups where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2242 * 2243 * @param companyId the company ID 2244 * @param parentGroupId the parent group ID 2245 * @param site the site 2246 * @param inheritContent the inherit content 2247 * @return the number of matching groups 2248 */ 2249 public static int countByC_P_S_I(long companyId, long parentGroupId, 2250 boolean site, boolean inheritContent) { 2251 return getPersistence() 2252 .countByC_P_S_I(companyId, parentGroupId, site, 2253 inheritContent); 2254 } 2255 2256 /** 2257 * Caches the group in the entity cache if it is enabled. 2258 * 2259 * @param group the group 2260 */ 2261 public static void cacheResult(Group group) { 2262 getPersistence().cacheResult(group); 2263 } 2264 2265 /** 2266 * Caches the groups in the entity cache if it is enabled. 2267 * 2268 * @param groups the groups 2269 */ 2270 public static void cacheResult(List<Group> groups) { 2271 getPersistence().cacheResult(groups); 2272 } 2273 2274 /** 2275 * Creates a new group with the primary key. Does not add the group to the database. 2276 * 2277 * @param groupId the primary key for the new group 2278 * @return the new group 2279 */ 2280 public static Group create(long groupId) { 2281 return getPersistence().create(groupId); 2282 } 2283 2284 /** 2285 * Removes the group with the primary key from the database. Also notifies the appropriate model listeners. 2286 * 2287 * @param groupId the primary key of the group 2288 * @return the group that was removed 2289 * @throws NoSuchGroupException if a group with the primary key could not be found 2290 */ 2291 public static Group remove(long groupId) 2292 throws com.liferay.portal.NoSuchGroupException { 2293 return getPersistence().remove(groupId); 2294 } 2295 2296 public static Group updateImpl(Group group) { 2297 return getPersistence().updateImpl(group); 2298 } 2299 2300 /** 2301 * Returns the group with the primary key or throws a {@link NoSuchGroupException} if it could not be found. 2302 * 2303 * @param groupId the primary key of the group 2304 * @return the group 2305 * @throws NoSuchGroupException if a group with the primary key could not be found 2306 */ 2307 public static Group findByPrimaryKey(long groupId) 2308 throws com.liferay.portal.NoSuchGroupException { 2309 return getPersistence().findByPrimaryKey(groupId); 2310 } 2311 2312 /** 2313 * Returns the group with the primary key or returns <code>null</code> if it could not be found. 2314 * 2315 * @param groupId the primary key of the group 2316 * @return the group, or <code>null</code> if a group with the primary key could not be found 2317 */ 2318 public static Group fetchByPrimaryKey(long groupId) { 2319 return getPersistence().fetchByPrimaryKey(groupId); 2320 } 2321 2322 public static java.util.Map<java.io.Serializable, Group> fetchByPrimaryKeys( 2323 java.util.Set<java.io.Serializable> primaryKeys) { 2324 return getPersistence().fetchByPrimaryKeys(primaryKeys); 2325 } 2326 2327 /** 2328 * Returns all the groups. 2329 * 2330 * @return the groups 2331 */ 2332 public static List<Group> findAll() { 2333 return getPersistence().findAll(); 2334 } 2335 2336 /** 2337 * Returns a range of all the groups. 2338 * 2339 * <p> 2340 * 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 GroupModelImpl}. 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. 2341 * </p> 2342 * 2343 * @param start the lower bound of the range of groups 2344 * @param end the upper bound of the range of groups (not inclusive) 2345 * @return the range of groups 2346 */ 2347 public static List<Group> findAll(int start, int end) { 2348 return getPersistence().findAll(start, end); 2349 } 2350 2351 /** 2352 * Returns an ordered range of all the groups. 2353 * 2354 * <p> 2355 * 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 GroupModelImpl}. 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. 2356 * </p> 2357 * 2358 * @param start the lower bound of the range of groups 2359 * @param end the upper bound of the range of groups (not inclusive) 2360 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2361 * @return the ordered range of groups 2362 */ 2363 public static List<Group> findAll(int start, int end, 2364 OrderByComparator<Group> orderByComparator) { 2365 return getPersistence().findAll(start, end, orderByComparator); 2366 } 2367 2368 /** 2369 * Removes all the groups from the database. 2370 */ 2371 public static void removeAll() { 2372 getPersistence().removeAll(); 2373 } 2374 2375 /** 2376 * Returns the number of groups. 2377 * 2378 * @return the number of groups 2379 */ 2380 public static int countAll() { 2381 return getPersistence().countAll(); 2382 } 2383 2384 /** 2385 * Returns the primaryKeys of organizations associated with the group. 2386 * 2387 * @param pk the primary key of the group 2388 * @return long[] of the primaryKeys of organizations associated with the group 2389 */ 2390 public static long[] getOrganizationPrimaryKeys(long pk) { 2391 return getPersistence().getOrganizationPrimaryKeys(pk); 2392 } 2393 2394 /** 2395 * Returns all the organizations associated with the group. 2396 * 2397 * @param pk the primary key of the group 2398 * @return the organizations associated with the group 2399 */ 2400 public static List<com.liferay.portal.model.Organization> getOrganizations( 2401 long pk) { 2402 return getPersistence().getOrganizations(pk); 2403 } 2404 2405 /** 2406 * Returns a range of all the organizations associated with the group. 2407 * 2408 * <p> 2409 * 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 GroupModelImpl}. 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. 2410 * </p> 2411 * 2412 * @param pk the primary key of the group 2413 * @param start the lower bound of the range of groups 2414 * @param end the upper bound of the range of groups (not inclusive) 2415 * @return the range of organizations associated with the group 2416 */ 2417 public static List<com.liferay.portal.model.Organization> getOrganizations( 2418 long pk, int start, int end) { 2419 return getPersistence().getOrganizations(pk, start, end); 2420 } 2421 2422 /** 2423 * Returns an ordered range of all the organizations associated with the group. 2424 * 2425 * <p> 2426 * 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 GroupModelImpl}. 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. 2427 * </p> 2428 * 2429 * @param pk the primary key of the group 2430 * @param start the lower bound of the range of groups 2431 * @param end the upper bound of the range of groups (not inclusive) 2432 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2433 * @return the ordered range of organizations associated with the group 2434 */ 2435 public static List<com.liferay.portal.model.Organization> getOrganizations( 2436 long pk, int start, int end, 2437 OrderByComparator<com.liferay.portal.model.Organization> orderByComparator) { 2438 return getPersistence() 2439 .getOrganizations(pk, start, end, orderByComparator); 2440 } 2441 2442 /** 2443 * Returns the number of organizations associated with the group. 2444 * 2445 * @param pk the primary key of the group 2446 * @return the number of organizations associated with the group 2447 */ 2448 public static int getOrganizationsSize(long pk) { 2449 return getPersistence().getOrganizationsSize(pk); 2450 } 2451 2452 /** 2453 * Returns <code>true</code> if the organization is associated with the group. 2454 * 2455 * @param pk the primary key of the group 2456 * @param organizationPK the primary key of the organization 2457 * @return <code>true</code> if the organization is associated with the group; <code>false</code> otherwise 2458 */ 2459 public static boolean containsOrganization(long pk, long organizationPK) { 2460 return getPersistence().containsOrganization(pk, organizationPK); 2461 } 2462 2463 /** 2464 * Returns <code>true</code> if the group has any organizations associated with it. 2465 * 2466 * @param pk the primary key of the group to check for associations with organizations 2467 * @return <code>true</code> if the group has any organizations associated with it; <code>false</code> otherwise 2468 */ 2469 public static boolean containsOrganizations(long pk) { 2470 return getPersistence().containsOrganizations(pk); 2471 } 2472 2473 /** 2474 * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2475 * 2476 * @param pk the primary key of the group 2477 * @param organizationPK the primary key of the organization 2478 */ 2479 public static void addOrganization(long pk, long organizationPK) { 2480 getPersistence().addOrganization(pk, organizationPK); 2481 } 2482 2483 /** 2484 * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2485 * 2486 * @param pk the primary key of the group 2487 * @param organization the organization 2488 */ 2489 public static void addOrganization(long pk, 2490 com.liferay.portal.model.Organization organization) { 2491 getPersistence().addOrganization(pk, organization); 2492 } 2493 2494 /** 2495 * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2496 * 2497 * @param pk the primary key of the group 2498 * @param organizationPKs the primary keys of the organizations 2499 */ 2500 public static void addOrganizations(long pk, long[] organizationPKs) { 2501 getPersistence().addOrganizations(pk, organizationPKs); 2502 } 2503 2504 /** 2505 * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2506 * 2507 * @param pk the primary key of the group 2508 * @param organizations the organizations 2509 */ 2510 public static void addOrganizations(long pk, 2511 List<com.liferay.portal.model.Organization> organizations) { 2512 getPersistence().addOrganizations(pk, organizations); 2513 } 2514 2515 /** 2516 * Clears all associations between the group and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2517 * 2518 * @param pk the primary key of the group to clear the associated organizations from 2519 */ 2520 public static void clearOrganizations(long pk) { 2521 getPersistence().clearOrganizations(pk); 2522 } 2523 2524 /** 2525 * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2526 * 2527 * @param pk the primary key of the group 2528 * @param organizationPK the primary key of the organization 2529 */ 2530 public static void removeOrganization(long pk, long organizationPK) { 2531 getPersistence().removeOrganization(pk, organizationPK); 2532 } 2533 2534 /** 2535 * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2536 * 2537 * @param pk the primary key of the group 2538 * @param organization the organization 2539 */ 2540 public static void removeOrganization(long pk, 2541 com.liferay.portal.model.Organization organization) { 2542 getPersistence().removeOrganization(pk, organization); 2543 } 2544 2545 /** 2546 * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2547 * 2548 * @param pk the primary key of the group 2549 * @param organizationPKs the primary keys of the organizations 2550 */ 2551 public static void removeOrganizations(long pk, long[] organizationPKs) { 2552 getPersistence().removeOrganizations(pk, organizationPKs); 2553 } 2554 2555 /** 2556 * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2557 * 2558 * @param pk the primary key of the group 2559 * @param organizations the organizations 2560 */ 2561 public static void removeOrganizations(long pk, 2562 List<com.liferay.portal.model.Organization> organizations) { 2563 getPersistence().removeOrganizations(pk, organizations); 2564 } 2565 2566 /** 2567 * Sets the organizations associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2568 * 2569 * @param pk the primary key of the group 2570 * @param organizationPKs the primary keys of the organizations to be associated with the group 2571 */ 2572 public static void setOrganizations(long pk, long[] organizationPKs) { 2573 getPersistence().setOrganizations(pk, organizationPKs); 2574 } 2575 2576 /** 2577 * Sets the organizations associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2578 * 2579 * @param pk the primary key of the group 2580 * @param organizations the organizations to be associated with the group 2581 */ 2582 public static void setOrganizations(long pk, 2583 List<com.liferay.portal.model.Organization> organizations) { 2584 getPersistence().setOrganizations(pk, organizations); 2585 } 2586 2587 /** 2588 * Returns the primaryKeys of roles associated with the group. 2589 * 2590 * @param pk the primary key of the group 2591 * @return long[] of the primaryKeys of roles associated with the group 2592 */ 2593 public static long[] getRolePrimaryKeys(long pk) { 2594 return getPersistence().getRolePrimaryKeys(pk); 2595 } 2596 2597 /** 2598 * Returns all the roles associated with the group. 2599 * 2600 * @param pk the primary key of the group 2601 * @return the roles associated with the group 2602 */ 2603 public static List<com.liferay.portal.model.Role> getRoles(long pk) { 2604 return getPersistence().getRoles(pk); 2605 } 2606 2607 /** 2608 * Returns a range of all the roles associated with the group. 2609 * 2610 * <p> 2611 * 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 GroupModelImpl}. 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. 2612 * </p> 2613 * 2614 * @param pk the primary key of the group 2615 * @param start the lower bound of the range of groups 2616 * @param end the upper bound of the range of groups (not inclusive) 2617 * @return the range of roles associated with the group 2618 */ 2619 public static List<com.liferay.portal.model.Role> getRoles(long pk, 2620 int start, int end) { 2621 return getPersistence().getRoles(pk, start, end); 2622 } 2623 2624 /** 2625 * Returns an ordered range of all the roles associated with the group. 2626 * 2627 * <p> 2628 * 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 GroupModelImpl}. 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. 2629 * </p> 2630 * 2631 * @param pk the primary key of the group 2632 * @param start the lower bound of the range of groups 2633 * @param end the upper bound of the range of groups (not inclusive) 2634 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2635 * @return the ordered range of roles associated with the group 2636 */ 2637 public static List<com.liferay.portal.model.Role> getRoles(long pk, 2638 int start, int end, 2639 OrderByComparator<com.liferay.portal.model.Role> orderByComparator) { 2640 return getPersistence().getRoles(pk, start, end, orderByComparator); 2641 } 2642 2643 /** 2644 * Returns the number of roles associated with the group. 2645 * 2646 * @param pk the primary key of the group 2647 * @return the number of roles associated with the group 2648 */ 2649 public static int getRolesSize(long pk) { 2650 return getPersistence().getRolesSize(pk); 2651 } 2652 2653 /** 2654 * Returns <code>true</code> if the role is associated with the group. 2655 * 2656 * @param pk the primary key of the group 2657 * @param rolePK the primary key of the role 2658 * @return <code>true</code> if the role is associated with the group; <code>false</code> otherwise 2659 */ 2660 public static boolean containsRole(long pk, long rolePK) { 2661 return getPersistence().containsRole(pk, rolePK); 2662 } 2663 2664 /** 2665 * Returns <code>true</code> if the group has any roles associated with it. 2666 * 2667 * @param pk the primary key of the group to check for associations with roles 2668 * @return <code>true</code> if the group has any roles associated with it; <code>false</code> otherwise 2669 */ 2670 public static boolean containsRoles(long pk) { 2671 return getPersistence().containsRoles(pk); 2672 } 2673 2674 /** 2675 * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2676 * 2677 * @param pk the primary key of the group 2678 * @param rolePK the primary key of the role 2679 */ 2680 public static void addRole(long pk, long rolePK) { 2681 getPersistence().addRole(pk, rolePK); 2682 } 2683 2684 /** 2685 * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2686 * 2687 * @param pk the primary key of the group 2688 * @param role the role 2689 */ 2690 public static void addRole(long pk, com.liferay.portal.model.Role role) { 2691 getPersistence().addRole(pk, role); 2692 } 2693 2694 /** 2695 * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2696 * 2697 * @param pk the primary key of the group 2698 * @param rolePKs the primary keys of the roles 2699 */ 2700 public static void addRoles(long pk, long[] rolePKs) { 2701 getPersistence().addRoles(pk, rolePKs); 2702 } 2703 2704 /** 2705 * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2706 * 2707 * @param pk the primary key of the group 2708 * @param roles the roles 2709 */ 2710 public static void addRoles(long pk, 2711 List<com.liferay.portal.model.Role> roles) { 2712 getPersistence().addRoles(pk, roles); 2713 } 2714 2715 /** 2716 * Clears all associations between the group and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2717 * 2718 * @param pk the primary key of the group to clear the associated roles from 2719 */ 2720 public static void clearRoles(long pk) { 2721 getPersistence().clearRoles(pk); 2722 } 2723 2724 /** 2725 * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2726 * 2727 * @param pk the primary key of the group 2728 * @param rolePK the primary key of the role 2729 */ 2730 public static void removeRole(long pk, long rolePK) { 2731 getPersistence().removeRole(pk, rolePK); 2732 } 2733 2734 /** 2735 * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2736 * 2737 * @param pk the primary key of the group 2738 * @param role the role 2739 */ 2740 public static void removeRole(long pk, com.liferay.portal.model.Role role) { 2741 getPersistence().removeRole(pk, role); 2742 } 2743 2744 /** 2745 * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2746 * 2747 * @param pk the primary key of the group 2748 * @param rolePKs the primary keys of the roles 2749 */ 2750 public static void removeRoles(long pk, long[] rolePKs) { 2751 getPersistence().removeRoles(pk, rolePKs); 2752 } 2753 2754 /** 2755 * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2756 * 2757 * @param pk the primary key of the group 2758 * @param roles the roles 2759 */ 2760 public static void removeRoles(long pk, 2761 List<com.liferay.portal.model.Role> roles) { 2762 getPersistence().removeRoles(pk, roles); 2763 } 2764 2765 /** 2766 * Sets the roles associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2767 * 2768 * @param pk the primary key of the group 2769 * @param rolePKs the primary keys of the roles to be associated with the group 2770 */ 2771 public static void setRoles(long pk, long[] rolePKs) { 2772 getPersistence().setRoles(pk, rolePKs); 2773 } 2774 2775 /** 2776 * Sets the roles associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2777 * 2778 * @param pk the primary key of the group 2779 * @param roles the roles to be associated with the group 2780 */ 2781 public static void setRoles(long pk, 2782 List<com.liferay.portal.model.Role> roles) { 2783 getPersistence().setRoles(pk, roles); 2784 } 2785 2786 /** 2787 * Returns the primaryKeys of user groups associated with the group. 2788 * 2789 * @param pk the primary key of the group 2790 * @return long[] of the primaryKeys of user groups associated with the group 2791 */ 2792 public static long[] getUserGroupPrimaryKeys(long pk) { 2793 return getPersistence().getUserGroupPrimaryKeys(pk); 2794 } 2795 2796 /** 2797 * Returns all the user groups associated with the group. 2798 * 2799 * @param pk the primary key of the group 2800 * @return the user groups associated with the group 2801 */ 2802 public static List<com.liferay.portal.model.UserGroup> getUserGroups( 2803 long pk) { 2804 return getPersistence().getUserGroups(pk); 2805 } 2806 2807 /** 2808 * Returns a range of all the user groups associated with the group. 2809 * 2810 * <p> 2811 * 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 GroupModelImpl}. 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. 2812 * </p> 2813 * 2814 * @param pk the primary key of the group 2815 * @param start the lower bound of the range of groups 2816 * @param end the upper bound of the range of groups (not inclusive) 2817 * @return the range of user groups associated with the group 2818 */ 2819 public static List<com.liferay.portal.model.UserGroup> getUserGroups( 2820 long pk, int start, int end) { 2821 return getPersistence().getUserGroups(pk, start, end); 2822 } 2823 2824 /** 2825 * Returns an ordered range of all the user groups associated with the group. 2826 * 2827 * <p> 2828 * 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 GroupModelImpl}. 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. 2829 * </p> 2830 * 2831 * @param pk the primary key of the group 2832 * @param start the lower bound of the range of groups 2833 * @param end the upper bound of the range of groups (not inclusive) 2834 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2835 * @return the ordered range of user groups associated with the group 2836 */ 2837 public static List<com.liferay.portal.model.UserGroup> getUserGroups( 2838 long pk, int start, int end, 2839 OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator) { 2840 return getPersistence().getUserGroups(pk, start, end, orderByComparator); 2841 } 2842 2843 /** 2844 * Returns the number of user groups associated with the group. 2845 * 2846 * @param pk the primary key of the group 2847 * @return the number of user groups associated with the group 2848 */ 2849 public static int getUserGroupsSize(long pk) { 2850 return getPersistence().getUserGroupsSize(pk); 2851 } 2852 2853 /** 2854 * Returns <code>true</code> if the user group is associated with the group. 2855 * 2856 * @param pk the primary key of the group 2857 * @param userGroupPK the primary key of the user group 2858 * @return <code>true</code> if the user group is associated with the group; <code>false</code> otherwise 2859 */ 2860 public static boolean containsUserGroup(long pk, long userGroupPK) { 2861 return getPersistence().containsUserGroup(pk, userGroupPK); 2862 } 2863 2864 /** 2865 * Returns <code>true</code> if the group has any user groups associated with it. 2866 * 2867 * @param pk the primary key of the group to check for associations with user groups 2868 * @return <code>true</code> if the group has any user groups associated with it; <code>false</code> otherwise 2869 */ 2870 public static boolean containsUserGroups(long pk) { 2871 return getPersistence().containsUserGroups(pk); 2872 } 2873 2874 /** 2875 * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2876 * 2877 * @param pk the primary key of the group 2878 * @param userGroupPK the primary key of the user group 2879 */ 2880 public static void addUserGroup(long pk, long userGroupPK) { 2881 getPersistence().addUserGroup(pk, userGroupPK); 2882 } 2883 2884 /** 2885 * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2886 * 2887 * @param pk the primary key of the group 2888 * @param userGroup the user group 2889 */ 2890 public static void addUserGroup(long pk, 2891 com.liferay.portal.model.UserGroup userGroup) { 2892 getPersistence().addUserGroup(pk, userGroup); 2893 } 2894 2895 /** 2896 * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2897 * 2898 * @param pk the primary key of the group 2899 * @param userGroupPKs the primary keys of the user groups 2900 */ 2901 public static void addUserGroups(long pk, long[] userGroupPKs) { 2902 getPersistence().addUserGroups(pk, userGroupPKs); 2903 } 2904 2905 /** 2906 * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2907 * 2908 * @param pk the primary key of the group 2909 * @param userGroups the user groups 2910 */ 2911 public static void addUserGroups(long pk, 2912 List<com.liferay.portal.model.UserGroup> userGroups) { 2913 getPersistence().addUserGroups(pk, userGroups); 2914 } 2915 2916 /** 2917 * Clears all associations between the group and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2918 * 2919 * @param pk the primary key of the group to clear the associated user groups from 2920 */ 2921 public static void clearUserGroups(long pk) { 2922 getPersistence().clearUserGroups(pk); 2923 } 2924 2925 /** 2926 * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2927 * 2928 * @param pk the primary key of the group 2929 * @param userGroupPK the primary key of the user group 2930 */ 2931 public static void removeUserGroup(long pk, long userGroupPK) { 2932 getPersistence().removeUserGroup(pk, userGroupPK); 2933 } 2934 2935 /** 2936 * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2937 * 2938 * @param pk the primary key of the group 2939 * @param userGroup the user group 2940 */ 2941 public static void removeUserGroup(long pk, 2942 com.liferay.portal.model.UserGroup userGroup) { 2943 getPersistence().removeUserGroup(pk, userGroup); 2944 } 2945 2946 /** 2947 * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2948 * 2949 * @param pk the primary key of the group 2950 * @param userGroupPKs the primary keys of the user groups 2951 */ 2952 public static void removeUserGroups(long pk, long[] userGroupPKs) { 2953 getPersistence().removeUserGroups(pk, userGroupPKs); 2954 } 2955 2956 /** 2957 * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2958 * 2959 * @param pk the primary key of the group 2960 * @param userGroups the user groups 2961 */ 2962 public static void removeUserGroups(long pk, 2963 List<com.liferay.portal.model.UserGroup> userGroups) { 2964 getPersistence().removeUserGroups(pk, userGroups); 2965 } 2966 2967 /** 2968 * Sets the user groups associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2969 * 2970 * @param pk the primary key of the group 2971 * @param userGroupPKs the primary keys of the user groups to be associated with the group 2972 */ 2973 public static void setUserGroups(long pk, long[] userGroupPKs) { 2974 getPersistence().setUserGroups(pk, userGroupPKs); 2975 } 2976 2977 /** 2978 * Sets the user groups associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2979 * 2980 * @param pk the primary key of the group 2981 * @param userGroups the user groups to be associated with the group 2982 */ 2983 public static void setUserGroups(long pk, 2984 List<com.liferay.portal.model.UserGroup> userGroups) { 2985 getPersistence().setUserGroups(pk, userGroups); 2986 } 2987 2988 /** 2989 * Returns the primaryKeys of users associated with the group. 2990 * 2991 * @param pk the primary key of the group 2992 * @return long[] of the primaryKeys of users associated with the group 2993 */ 2994 public static long[] getUserPrimaryKeys(long pk) { 2995 return getPersistence().getUserPrimaryKeys(pk); 2996 } 2997 2998 /** 2999 * Returns all the users associated with the group. 3000 * 3001 * @param pk the primary key of the group 3002 * @return the users associated with the group 3003 */ 3004 public static List<com.liferay.portal.model.User> getUsers(long pk) { 3005 return getPersistence().getUsers(pk); 3006 } 3007 3008 /** 3009 * Returns a range of all the users associated with the group. 3010 * 3011 * <p> 3012 * 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 GroupModelImpl}. 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. 3013 * </p> 3014 * 3015 * @param pk the primary key of the group 3016 * @param start the lower bound of the range of groups 3017 * @param end the upper bound of the range of groups (not inclusive) 3018 * @return the range of users associated with the group 3019 */ 3020 public static List<com.liferay.portal.model.User> getUsers(long pk, 3021 int start, int end) { 3022 return getPersistence().getUsers(pk, start, end); 3023 } 3024 3025 /** 3026 * Returns an ordered range of all the users associated with the group. 3027 * 3028 * <p> 3029 * 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 GroupModelImpl}. 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. 3030 * </p> 3031 * 3032 * @param pk the primary key of the group 3033 * @param start the lower bound of the range of groups 3034 * @param end the upper bound of the range of groups (not inclusive) 3035 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3036 * @return the ordered range of users associated with the group 3037 */ 3038 public static List<com.liferay.portal.model.User> getUsers(long pk, 3039 int start, int end, 3040 OrderByComparator<com.liferay.portal.model.User> orderByComparator) { 3041 return getPersistence().getUsers(pk, start, end, orderByComparator); 3042 } 3043 3044 /** 3045 * Returns the number of users associated with the group. 3046 * 3047 * @param pk the primary key of the group 3048 * @return the number of users associated with the group 3049 */ 3050 public static int getUsersSize(long pk) { 3051 return getPersistence().getUsersSize(pk); 3052 } 3053 3054 /** 3055 * Returns <code>true</code> if the user is associated with the group. 3056 * 3057 * @param pk the primary key of the group 3058 * @param userPK the primary key of the user 3059 * @return <code>true</code> if the user is associated with the group; <code>false</code> otherwise 3060 */ 3061 public static boolean containsUser(long pk, long userPK) { 3062 return getPersistence().containsUser(pk, userPK); 3063 } 3064 3065 /** 3066 * Returns <code>true</code> if the group has any users associated with it. 3067 * 3068 * @param pk the primary key of the group to check for associations with users 3069 * @return <code>true</code> if the group has any users associated with it; <code>false</code> otherwise 3070 */ 3071 public static boolean containsUsers(long pk) { 3072 return getPersistence().containsUsers(pk); 3073 } 3074 3075 /** 3076 * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3077 * 3078 * @param pk the primary key of the group 3079 * @param userPK the primary key of the user 3080 */ 3081 public static void addUser(long pk, long userPK) { 3082 getPersistence().addUser(pk, userPK); 3083 } 3084 3085 /** 3086 * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3087 * 3088 * @param pk the primary key of the group 3089 * @param user the user 3090 */ 3091 public static void addUser(long pk, com.liferay.portal.model.User user) { 3092 getPersistence().addUser(pk, user); 3093 } 3094 3095 /** 3096 * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3097 * 3098 * @param pk the primary key of the group 3099 * @param userPKs the primary keys of the users 3100 */ 3101 public static void addUsers(long pk, long[] userPKs) { 3102 getPersistence().addUsers(pk, userPKs); 3103 } 3104 3105 /** 3106 * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3107 * 3108 * @param pk the primary key of the group 3109 * @param users the users 3110 */ 3111 public static void addUsers(long pk, 3112 List<com.liferay.portal.model.User> users) { 3113 getPersistence().addUsers(pk, users); 3114 } 3115 3116 /** 3117 * Clears all associations between the group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3118 * 3119 * @param pk the primary key of the group to clear the associated users from 3120 */ 3121 public static void clearUsers(long pk) { 3122 getPersistence().clearUsers(pk); 3123 } 3124 3125 /** 3126 * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3127 * 3128 * @param pk the primary key of the group 3129 * @param userPK the primary key of the user 3130 */ 3131 public static void removeUser(long pk, long userPK) { 3132 getPersistence().removeUser(pk, userPK); 3133 } 3134 3135 /** 3136 * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3137 * 3138 * @param pk the primary key of the group 3139 * @param user the user 3140 */ 3141 public static void removeUser(long pk, com.liferay.portal.model.User user) { 3142 getPersistence().removeUser(pk, user); 3143 } 3144 3145 /** 3146 * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3147 * 3148 * @param pk the primary key of the group 3149 * @param userPKs the primary keys of the users 3150 */ 3151 public static void removeUsers(long pk, long[] userPKs) { 3152 getPersistence().removeUsers(pk, userPKs); 3153 } 3154 3155 /** 3156 * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3157 * 3158 * @param pk the primary key of the group 3159 * @param users the users 3160 */ 3161 public static void removeUsers(long pk, 3162 List<com.liferay.portal.model.User> users) { 3163 getPersistence().removeUsers(pk, users); 3164 } 3165 3166 /** 3167 * Sets the users associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3168 * 3169 * @param pk the primary key of the group 3170 * @param userPKs the primary keys of the users to be associated with the group 3171 */ 3172 public static void setUsers(long pk, long[] userPKs) { 3173 getPersistence().setUsers(pk, userPKs); 3174 } 3175 3176 /** 3177 * Sets the users associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3178 * 3179 * @param pk the primary key of the group 3180 * @param users the users to be associated with the group 3181 */ 3182 public static void setUsers(long pk, 3183 List<com.liferay.portal.model.User> users) { 3184 getPersistence().setUsers(pk, users); 3185 } 3186 3187 public static GroupPersistence getPersistence() { 3188 if (_persistence == null) { 3189 _persistence = (GroupPersistence)PortalBeanLocatorUtil.locate(GroupPersistence.class.getName()); 3190 3191 ReferenceRegistry.registerReference(GroupUtil.class, "_persistence"); 3192 } 3193 3194 return _persistence; 3195 } 3196 3197 /** 3198 * @deprecated As of 6.2.0 3199 */ 3200 @Deprecated 3201 public void setPersistence(GroupPersistence persistence) { 3202 } 3203 3204 private static GroupPersistence _persistence; 3205 }