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