001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * The contents of this file are subject to the terms of the Liferay Enterprise 005 * Subscription License ("License"). You may not use this file except in 006 * compliance with the License. You can obtain a copy of the License by 007 * contacting Liferay, Inc. See the License for the specific language governing 008 * permissions and limitations under the License, including but not limited to 009 * distribution rights of the Software. 010 * 011 * 012 * 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 companyId = ? and active = ?. 1430 * 1431 * @param companyId the company ID 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> findByC_A( 1437 long companyId, boolean active) 1438 throws com.liferay.portal.kernel.exception.SystemException { 1439 return getPersistence().findByC_A(companyId, active); 1440 } 1441 1442 /** 1443 * Returns a range of all the groups where companyId = ? 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 companyId the company ID 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> findByC_A( 1457 long companyId, boolean active, int start, int end) 1458 throws com.liferay.portal.kernel.exception.SystemException { 1459 return getPersistence().findByC_A(companyId, active, start, end); 1460 } 1461 1462 /** 1463 * Returns an ordered range of all the groups where companyId = ? 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 companyId the company ID 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> findByC_A( 1478 long companyId, 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 .findByC_A(companyId, active, start, end, orderByComparator); 1483 } 1484 1485 /** 1486 * Returns the first group in the ordered set where companyId = ? and active = ?. 1487 * 1488 * @param companyId the company ID 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 findByC_A_First( 1496 long companyId, 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() 1501 .findByC_A_First(companyId, active, orderByComparator); 1502 } 1503 1504 /** 1505 * Returns the first group in the ordered set where companyId = ? and active = ?. 1506 * 1507 * @param companyId the company ID 1508 * @param active the active 1509 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1510 * @return the first matching group, or <code>null</code> if a matching group could not be found 1511 * @throws SystemException if a system exception occurred 1512 */ 1513 public static com.liferay.portal.model.Group fetchByC_A_First( 1514 long companyId, boolean active, 1515 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1516 throws com.liferay.portal.kernel.exception.SystemException { 1517 return getPersistence() 1518 .fetchByC_A_First(companyId, active, orderByComparator); 1519 } 1520 1521 /** 1522 * Returns the last group in the ordered set where companyId = ? and active = ?. 1523 * 1524 * @param companyId the company ID 1525 * @param active the active 1526 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1527 * @return the last matching group 1528 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 1529 * @throws SystemException if a system exception occurred 1530 */ 1531 public static com.liferay.portal.model.Group findByC_A_Last( 1532 long companyId, boolean active, 1533 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1534 throws com.liferay.portal.NoSuchGroupException, 1535 com.liferay.portal.kernel.exception.SystemException { 1536 return getPersistence() 1537 .findByC_A_Last(companyId, active, orderByComparator); 1538 } 1539 1540 /** 1541 * Returns the last group in the ordered set where companyId = ? and active = ?. 1542 * 1543 * @param companyId the company ID 1544 * @param active the active 1545 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1546 * @return the last matching group, or <code>null</code> if a matching group could not be found 1547 * @throws SystemException if a system exception occurred 1548 */ 1549 public static com.liferay.portal.model.Group fetchByC_A_Last( 1550 long companyId, boolean active, 1551 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1552 throws com.liferay.portal.kernel.exception.SystemException { 1553 return getPersistence() 1554 .fetchByC_A_Last(companyId, active, orderByComparator); 1555 } 1556 1557 /** 1558 * Returns the groups before and after the current group in the ordered set where companyId = ? and active = ?. 1559 * 1560 * @param groupId the primary key of the current group 1561 * @param companyId the company ID 1562 * @param active the active 1563 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1564 * @return the previous, current, and next group 1565 * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found 1566 * @throws SystemException if a system exception occurred 1567 */ 1568 public static com.liferay.portal.model.Group[] findByC_A_PrevAndNext( 1569 long groupId, long companyId, boolean active, 1570 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1571 throws com.liferay.portal.NoSuchGroupException, 1572 com.liferay.portal.kernel.exception.SystemException { 1573 return getPersistence() 1574 .findByC_A_PrevAndNext(groupId, companyId, active, 1575 orderByComparator); 1576 } 1577 1578 /** 1579 * Removes all the groups where companyId = ? and active = ? from the database. 1580 * 1581 * @param companyId the company ID 1582 * @param active the active 1583 * @throws SystemException if a system exception occurred 1584 */ 1585 public static void removeByC_A(long companyId, boolean active) 1586 throws com.liferay.portal.kernel.exception.SystemException { 1587 getPersistence().removeByC_A(companyId, active); 1588 } 1589 1590 /** 1591 * Returns the number of groups where companyId = ? and active = ?. 1592 * 1593 * @param companyId the company ID 1594 * @param active the active 1595 * @return the number of matching groups 1596 * @throws SystemException if a system exception occurred 1597 */ 1598 public static int countByC_A(long companyId, boolean active) 1599 throws com.liferay.portal.kernel.exception.SystemException { 1600 return getPersistence().countByC_A(companyId, active); 1601 } 1602 1603 /** 1604 * Returns all the groups where type = ? and active = ?. 1605 * 1606 * @param type the type 1607 * @param active the active 1608 * @return the matching groups 1609 * @throws SystemException if a system exception occurred 1610 */ 1611 public static java.util.List<com.liferay.portal.model.Group> findByT_A( 1612 int type, boolean active) 1613 throws com.liferay.portal.kernel.exception.SystemException { 1614 return getPersistence().findByT_A(type, active); 1615 } 1616 1617 /** 1618 * Returns a range of all the groups where type = ? and active = ?. 1619 * 1620 * <p> 1621 * 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. 1622 * </p> 1623 * 1624 * @param type the type 1625 * @param active the active 1626 * @param start the lower bound of the range of groups 1627 * @param end the upper bound of the range of groups (not inclusive) 1628 * @return the range of matching groups 1629 * @throws SystemException if a system exception occurred 1630 */ 1631 public static java.util.List<com.liferay.portal.model.Group> findByT_A( 1632 int type, boolean active, int start, int end) 1633 throws com.liferay.portal.kernel.exception.SystemException { 1634 return getPersistence().findByT_A(type, active, start, end); 1635 } 1636 1637 /** 1638 * Returns an ordered range of all the groups where type = ? and active = ?. 1639 * 1640 * <p> 1641 * 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. 1642 * </p> 1643 * 1644 * @param type the type 1645 * @param active the active 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> findByT_A( 1653 int type, boolean active, int start, int end, 1654 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1655 throws com.liferay.portal.kernel.exception.SystemException { 1656 return getPersistence() 1657 .findByT_A(type, active, start, end, orderByComparator); 1658 } 1659 1660 /** 1661 * Returns the first group in the ordered set where type = ? and active = ?. 1662 * 1663 * @param type the type 1664 * @param active the active 1665 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1666 * @return the first matching group 1667 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 1668 * @throws SystemException if a system exception occurred 1669 */ 1670 public static com.liferay.portal.model.Group findByT_A_First(int type, 1671 boolean active, 1672 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1673 throws com.liferay.portal.NoSuchGroupException, 1674 com.liferay.portal.kernel.exception.SystemException { 1675 return getPersistence().findByT_A_First(type, active, orderByComparator); 1676 } 1677 1678 /** 1679 * Returns the first group in the ordered set where type = ? and active = ?. 1680 * 1681 * @param type the type 1682 * @param active the active 1683 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1684 * @return the first matching group, or <code>null</code> if a matching group could not be found 1685 * @throws SystemException if a system exception occurred 1686 */ 1687 public static com.liferay.portal.model.Group fetchByT_A_First(int type, 1688 boolean active, 1689 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1690 throws com.liferay.portal.kernel.exception.SystemException { 1691 return getPersistence().fetchByT_A_First(type, active, orderByComparator); 1692 } 1693 1694 /** 1695 * Returns the last group in the ordered set where type = ? and active = ?. 1696 * 1697 * @param type the type 1698 * @param active the active 1699 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1700 * @return the last matching group 1701 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 1702 * @throws SystemException if a system exception occurred 1703 */ 1704 public static com.liferay.portal.model.Group findByT_A_Last(int type, 1705 boolean active, 1706 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1707 throws com.liferay.portal.NoSuchGroupException, 1708 com.liferay.portal.kernel.exception.SystemException { 1709 return getPersistence().findByT_A_Last(type, active, orderByComparator); 1710 } 1711 1712 /** 1713 * Returns the last group in the ordered set where type = ? and active = ?. 1714 * 1715 * @param type the type 1716 * @param active the active 1717 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1718 * @return the last matching group, or <code>null</code> if a matching group could not be found 1719 * @throws SystemException if a system exception occurred 1720 */ 1721 public static com.liferay.portal.model.Group fetchByT_A_Last(int type, 1722 boolean active, 1723 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1724 throws com.liferay.portal.kernel.exception.SystemException { 1725 return getPersistence().fetchByT_A_Last(type, active, orderByComparator); 1726 } 1727 1728 /** 1729 * Returns the groups before and after the current group in the ordered set where type = ? and active = ?. 1730 * 1731 * @param groupId the primary key of the current group 1732 * @param type the type 1733 * @param active the active 1734 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1735 * @return the previous, current, and next group 1736 * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found 1737 * @throws SystemException if a system exception occurred 1738 */ 1739 public static com.liferay.portal.model.Group[] findByT_A_PrevAndNext( 1740 long groupId, int type, boolean active, 1741 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1742 throws com.liferay.portal.NoSuchGroupException, 1743 com.liferay.portal.kernel.exception.SystemException { 1744 return getPersistence() 1745 .findByT_A_PrevAndNext(groupId, type, active, 1746 orderByComparator); 1747 } 1748 1749 /** 1750 * Removes all the groups where type = ? and active = ? from the database. 1751 * 1752 * @param type the type 1753 * @param active the active 1754 * @throws SystemException if a system exception occurred 1755 */ 1756 public static void removeByT_A(int type, boolean active) 1757 throws com.liferay.portal.kernel.exception.SystemException { 1758 getPersistence().removeByT_A(type, active); 1759 } 1760 1761 /** 1762 * Returns the number of groups where type = ? and active = ?. 1763 * 1764 * @param type the type 1765 * @param active the active 1766 * @return the number of matching groups 1767 * @throws SystemException if a system exception occurred 1768 */ 1769 public static int countByT_A(int type, boolean active) 1770 throws com.liferay.portal.kernel.exception.SystemException { 1771 return getPersistence().countByT_A(type, active); 1772 } 1773 1774 /** 1775 * Returns all the groups where groupId > ? and companyId = ? and parentGroupId = ?. 1776 * 1777 * @param groupId the group ID 1778 * @param companyId the company ID 1779 * @param parentGroupId the parent group ID 1780 * @return the matching groups 1781 * @throws SystemException if a system exception occurred 1782 */ 1783 public static java.util.List<com.liferay.portal.model.Group> findByG_C_P( 1784 long groupId, long companyId, long parentGroupId) 1785 throws com.liferay.portal.kernel.exception.SystemException { 1786 return getPersistence().findByG_C_P(groupId, companyId, parentGroupId); 1787 } 1788 1789 /** 1790 * Returns a range of all the groups where groupId > ? and companyId = ? and parentGroupId = ?. 1791 * 1792 * <p> 1793 * 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. 1794 * </p> 1795 * 1796 * @param groupId the group ID 1797 * @param companyId the company ID 1798 * @param parentGroupId the parent group ID 1799 * @param start the lower bound of the range of groups 1800 * @param end the upper bound of the range of groups (not inclusive) 1801 * @return the range of matching groups 1802 * @throws SystemException if a system exception occurred 1803 */ 1804 public static java.util.List<com.liferay.portal.model.Group> findByG_C_P( 1805 long groupId, long companyId, long parentGroupId, int start, int end) 1806 throws com.liferay.portal.kernel.exception.SystemException { 1807 return getPersistence() 1808 .findByG_C_P(groupId, companyId, parentGroupId, start, end); 1809 } 1810 1811 /** 1812 * Returns an ordered range of all the groups where groupId > ? and companyId = ? and parentGroupId = ?. 1813 * 1814 * <p> 1815 * 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. 1816 * </p> 1817 * 1818 * @param groupId the group ID 1819 * @param companyId the company ID 1820 * @param parentGroupId the parent group ID 1821 * @param start the lower bound of the range of groups 1822 * @param end the upper bound of the range of groups (not inclusive) 1823 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1824 * @return the ordered range of matching groups 1825 * @throws SystemException if a system exception occurred 1826 */ 1827 public static java.util.List<com.liferay.portal.model.Group> findByG_C_P( 1828 long groupId, long companyId, long parentGroupId, int start, int end, 1829 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1830 throws com.liferay.portal.kernel.exception.SystemException { 1831 return getPersistence() 1832 .findByG_C_P(groupId, companyId, parentGroupId, start, end, 1833 orderByComparator); 1834 } 1835 1836 /** 1837 * Returns the first group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1838 * 1839 * @param groupId the group ID 1840 * @param companyId the company ID 1841 * @param parentGroupId the parent group ID 1842 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1843 * @return the first matching group 1844 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 1845 * @throws SystemException if a system exception occurred 1846 */ 1847 public static com.liferay.portal.model.Group findByG_C_P_First( 1848 long groupId, long companyId, long parentGroupId, 1849 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1850 throws com.liferay.portal.NoSuchGroupException, 1851 com.liferay.portal.kernel.exception.SystemException { 1852 return getPersistence() 1853 .findByG_C_P_First(groupId, companyId, parentGroupId, 1854 orderByComparator); 1855 } 1856 1857 /** 1858 * Returns the first group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1859 * 1860 * @param groupId the group ID 1861 * @param companyId the company ID 1862 * @param parentGroupId the parent group ID 1863 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1864 * @return the first matching group, or <code>null</code> if a matching group could not be found 1865 * @throws SystemException if a system exception occurred 1866 */ 1867 public static com.liferay.portal.model.Group fetchByG_C_P_First( 1868 long groupId, long companyId, long parentGroupId, 1869 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1870 throws com.liferay.portal.kernel.exception.SystemException { 1871 return getPersistence() 1872 .fetchByG_C_P_First(groupId, companyId, parentGroupId, 1873 orderByComparator); 1874 } 1875 1876 /** 1877 * Returns the last group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1878 * 1879 * @param groupId the group ID 1880 * @param companyId the company ID 1881 * @param parentGroupId the parent group ID 1882 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1883 * @return the last matching group 1884 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 1885 * @throws SystemException if a system exception occurred 1886 */ 1887 public static com.liferay.portal.model.Group findByG_C_P_Last( 1888 long groupId, long companyId, long parentGroupId, 1889 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1890 throws com.liferay.portal.NoSuchGroupException, 1891 com.liferay.portal.kernel.exception.SystemException { 1892 return getPersistence() 1893 .findByG_C_P_Last(groupId, companyId, parentGroupId, 1894 orderByComparator); 1895 } 1896 1897 /** 1898 * Returns the last group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1899 * 1900 * @param groupId the group ID 1901 * @param companyId the company ID 1902 * @param parentGroupId the parent group ID 1903 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1904 * @return the last matching group, or <code>null</code> if a matching group could not be found 1905 * @throws SystemException if a system exception occurred 1906 */ 1907 public static com.liferay.portal.model.Group fetchByG_C_P_Last( 1908 long groupId, long companyId, long parentGroupId, 1909 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1910 throws com.liferay.portal.kernel.exception.SystemException { 1911 return getPersistence() 1912 .fetchByG_C_P_Last(groupId, companyId, parentGroupId, 1913 orderByComparator); 1914 } 1915 1916 /** 1917 * Removes all the groups where groupId > ? and companyId = ? and parentGroupId = ? from the database. 1918 * 1919 * @param groupId the group ID 1920 * @param companyId the company ID 1921 * @param parentGroupId the parent group ID 1922 * @throws SystemException if a system exception occurred 1923 */ 1924 public static void removeByG_C_P(long groupId, long companyId, 1925 long parentGroupId) 1926 throws com.liferay.portal.kernel.exception.SystemException { 1927 getPersistence().removeByG_C_P(groupId, companyId, parentGroupId); 1928 } 1929 1930 /** 1931 * Returns the number of groups where groupId > ? and companyId = ? and parentGroupId = ?. 1932 * 1933 * @param groupId the group ID 1934 * @param companyId the company ID 1935 * @param parentGroupId the parent group ID 1936 * @return the number of matching groups 1937 * @throws SystemException if a system exception occurred 1938 */ 1939 public static int countByG_C_P(long groupId, long companyId, 1940 long parentGroupId) 1941 throws com.liferay.portal.kernel.exception.SystemException { 1942 return getPersistence().countByG_C_P(groupId, companyId, parentGroupId); 1943 } 1944 1945 /** 1946 * Returns the group where companyId = ? and classNameId = ? and classPK = ? or throws a {@link com.liferay.portal.NoSuchGroupException} if it could not be found. 1947 * 1948 * @param companyId the company ID 1949 * @param classNameId the class name ID 1950 * @param classPK the class p k 1951 * @return the matching group 1952 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 1953 * @throws SystemException if a system exception occurred 1954 */ 1955 public static com.liferay.portal.model.Group findByC_C_C(long companyId, 1956 long classNameId, long classPK) 1957 throws com.liferay.portal.NoSuchGroupException, 1958 com.liferay.portal.kernel.exception.SystemException { 1959 return getPersistence().findByC_C_C(companyId, classNameId, classPK); 1960 } 1961 1962 /** 1963 * Returns the group where companyId = ? and classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1964 * 1965 * @param companyId the company ID 1966 * @param classNameId the class name ID 1967 * @param classPK the class p k 1968 * @return the matching group, or <code>null</code> if a matching group could not be found 1969 * @throws SystemException if a system exception occurred 1970 */ 1971 public static com.liferay.portal.model.Group fetchByC_C_C(long companyId, 1972 long classNameId, long classPK) 1973 throws com.liferay.portal.kernel.exception.SystemException { 1974 return getPersistence().fetchByC_C_C(companyId, classNameId, classPK); 1975 } 1976 1977 /** 1978 * 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. 1979 * 1980 * @param companyId the company ID 1981 * @param classNameId the class name ID 1982 * @param classPK the class p k 1983 * @param retrieveFromCache whether to use the finder cache 1984 * @return the 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_C(long companyId, 1988 long classNameId, long classPK, boolean retrieveFromCache) 1989 throws com.liferay.portal.kernel.exception.SystemException { 1990 return getPersistence() 1991 .fetchByC_C_C(companyId, classNameId, classPK, 1992 retrieveFromCache); 1993 } 1994 1995 /** 1996 * Removes the group where companyId = ? and classNameId = ? and classPK = ? from the database. 1997 * 1998 * @param companyId the company ID 1999 * @param classNameId the class name ID 2000 * @param classPK the class p k 2001 * @return the group that was removed 2002 * @throws SystemException if a system exception occurred 2003 */ 2004 public static com.liferay.portal.model.Group removeByC_C_C(long companyId, 2005 long classNameId, long classPK) 2006 throws com.liferay.portal.NoSuchGroupException, 2007 com.liferay.portal.kernel.exception.SystemException { 2008 return getPersistence().removeByC_C_C(companyId, classNameId, classPK); 2009 } 2010 2011 /** 2012 * Returns the number of groups where companyId = ? and classNameId = ? and classPK = ?. 2013 * 2014 * @param companyId the company ID 2015 * @param classNameId the class name ID 2016 * @param classPK the class p k 2017 * @return the number of matching groups 2018 * @throws SystemException if a system exception occurred 2019 */ 2020 public static int countByC_C_C(long companyId, long classNameId, 2021 long classPK) 2022 throws com.liferay.portal.kernel.exception.SystemException { 2023 return getPersistence().countByC_C_C(companyId, classNameId, classPK); 2024 } 2025 2026 /** 2027 * Returns all the groups where companyId = ? and classNameId = ? and parentGroupId = ?. 2028 * 2029 * @param companyId the company ID 2030 * @param classNameId the class name ID 2031 * @param parentGroupId the parent group ID 2032 * @return the matching groups 2033 * @throws SystemException if a system exception occurred 2034 */ 2035 public static java.util.List<com.liferay.portal.model.Group> findByC_C_P( 2036 long companyId, long classNameId, long parentGroupId) 2037 throws com.liferay.portal.kernel.exception.SystemException { 2038 return getPersistence() 2039 .findByC_C_P(companyId, classNameId, parentGroupId); 2040 } 2041 2042 /** 2043 * Returns a range of all the groups where companyId = ? and classNameId = ? and parentGroupId = ?. 2044 * 2045 * <p> 2046 * 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. 2047 * </p> 2048 * 2049 * @param companyId the company ID 2050 * @param classNameId the class name ID 2051 * @param parentGroupId the parent group ID 2052 * @param start the lower bound of the range of groups 2053 * @param end the upper bound of the range of groups (not inclusive) 2054 * @return the range of matching groups 2055 * @throws SystemException if a system exception occurred 2056 */ 2057 public static java.util.List<com.liferay.portal.model.Group> findByC_C_P( 2058 long companyId, long classNameId, long parentGroupId, int start, int end) 2059 throws com.liferay.portal.kernel.exception.SystemException { 2060 return getPersistence() 2061 .findByC_C_P(companyId, classNameId, parentGroupId, start, 2062 end); 2063 } 2064 2065 /** 2066 * Returns an ordered range of all the groups where companyId = ? and classNameId = ? and parentGroupId = ?. 2067 * 2068 * <p> 2069 * 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. 2070 * </p> 2071 * 2072 * @param companyId the company ID 2073 * @param classNameId the class name ID 2074 * @param parentGroupId the parent group ID 2075 * @param start the lower bound of the range of groups 2076 * @param end the upper bound of the range of groups (not inclusive) 2077 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2078 * @return the ordered range of matching groups 2079 * @throws SystemException if a system exception occurred 2080 */ 2081 public static java.util.List<com.liferay.portal.model.Group> findByC_C_P( 2082 long companyId, long classNameId, long parentGroupId, int start, 2083 int end, 2084 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2085 throws com.liferay.portal.kernel.exception.SystemException { 2086 return getPersistence() 2087 .findByC_C_P(companyId, classNameId, parentGroupId, start, 2088 end, orderByComparator); 2089 } 2090 2091 /** 2092 * Returns the first group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 2093 * 2094 * @param companyId the company ID 2095 * @param classNameId the class name ID 2096 * @param parentGroupId the parent group ID 2097 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2098 * @return the first matching group 2099 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 2100 * @throws SystemException if a system exception occurred 2101 */ 2102 public static com.liferay.portal.model.Group findByC_C_P_First( 2103 long companyId, long classNameId, long parentGroupId, 2104 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2105 throws com.liferay.portal.NoSuchGroupException, 2106 com.liferay.portal.kernel.exception.SystemException { 2107 return getPersistence() 2108 .findByC_C_P_First(companyId, classNameId, parentGroupId, 2109 orderByComparator); 2110 } 2111 2112 /** 2113 * Returns the first group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 2114 * 2115 * @param companyId the company ID 2116 * @param classNameId the class name ID 2117 * @param parentGroupId the parent group ID 2118 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2119 * @return the first matching group, or <code>null</code> if a matching group could not be found 2120 * @throws SystemException if a system exception occurred 2121 */ 2122 public static com.liferay.portal.model.Group fetchByC_C_P_First( 2123 long companyId, long classNameId, long parentGroupId, 2124 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2125 throws com.liferay.portal.kernel.exception.SystemException { 2126 return getPersistence() 2127 .fetchByC_C_P_First(companyId, classNameId, parentGroupId, 2128 orderByComparator); 2129 } 2130 2131 /** 2132 * Returns the last group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 2133 * 2134 * @param companyId the company ID 2135 * @param classNameId the class name ID 2136 * @param parentGroupId the parent group ID 2137 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2138 * @return the last matching group 2139 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 2140 * @throws SystemException if a system exception occurred 2141 */ 2142 public static com.liferay.portal.model.Group findByC_C_P_Last( 2143 long companyId, long classNameId, long parentGroupId, 2144 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2145 throws com.liferay.portal.NoSuchGroupException, 2146 com.liferay.portal.kernel.exception.SystemException { 2147 return getPersistence() 2148 .findByC_C_P_Last(companyId, classNameId, parentGroupId, 2149 orderByComparator); 2150 } 2151 2152 /** 2153 * Returns the last group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 2154 * 2155 * @param companyId the company ID 2156 * @param classNameId the class name ID 2157 * @param parentGroupId the parent group ID 2158 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2159 * @return the last matching group, or <code>null</code> if a matching group could not be found 2160 * @throws SystemException if a system exception occurred 2161 */ 2162 public static com.liferay.portal.model.Group fetchByC_C_P_Last( 2163 long companyId, long classNameId, long parentGroupId, 2164 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2165 throws com.liferay.portal.kernel.exception.SystemException { 2166 return getPersistence() 2167 .fetchByC_C_P_Last(companyId, classNameId, parentGroupId, 2168 orderByComparator); 2169 } 2170 2171 /** 2172 * Returns the groups before and after the current group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 2173 * 2174 * @param groupId the primary key of the current group 2175 * @param companyId the company ID 2176 * @param classNameId the class name ID 2177 * @param parentGroupId the parent group ID 2178 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2179 * @return the previous, current, and next group 2180 * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found 2181 * @throws SystemException if a system exception occurred 2182 */ 2183 public static com.liferay.portal.model.Group[] findByC_C_P_PrevAndNext( 2184 long groupId, long companyId, long classNameId, long parentGroupId, 2185 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2186 throws com.liferay.portal.NoSuchGroupException, 2187 com.liferay.portal.kernel.exception.SystemException { 2188 return getPersistence() 2189 .findByC_C_P_PrevAndNext(groupId, companyId, classNameId, 2190 parentGroupId, orderByComparator); 2191 } 2192 2193 /** 2194 * Removes all the groups where companyId = ? and classNameId = ? and parentGroupId = ? from the database. 2195 * 2196 * @param companyId the company ID 2197 * @param classNameId the class name ID 2198 * @param parentGroupId the parent group ID 2199 * @throws SystemException if a system exception occurred 2200 */ 2201 public static void removeByC_C_P(long companyId, long classNameId, 2202 long parentGroupId) 2203 throws com.liferay.portal.kernel.exception.SystemException { 2204 getPersistence().removeByC_C_P(companyId, classNameId, parentGroupId); 2205 } 2206 2207 /** 2208 * Returns the number of groups where companyId = ? and classNameId = ? and parentGroupId = ?. 2209 * 2210 * @param companyId the company ID 2211 * @param classNameId the class name ID 2212 * @param parentGroupId the parent group ID 2213 * @return the number of matching groups 2214 * @throws SystemException if a system exception occurred 2215 */ 2216 public static int countByC_C_P(long companyId, long classNameId, 2217 long parentGroupId) 2218 throws com.liferay.portal.kernel.exception.SystemException { 2219 return getPersistence() 2220 .countByC_C_P(companyId, classNameId, parentGroupId); 2221 } 2222 2223 /** 2224 * Returns all the groups where companyId = ? and parentGroupId = ? and site = ?. 2225 * 2226 * @param companyId the company ID 2227 * @param parentGroupId the parent group ID 2228 * @param site the site 2229 * @return the matching groups 2230 * @throws SystemException if a system exception occurred 2231 */ 2232 public static java.util.List<com.liferay.portal.model.Group> findByC_P_S( 2233 long companyId, long parentGroupId, boolean site) 2234 throws com.liferay.portal.kernel.exception.SystemException { 2235 return getPersistence().findByC_P_S(companyId, parentGroupId, site); 2236 } 2237 2238 /** 2239 * Returns a range of all the groups where companyId = ? and parentGroupId = ? and site = ?. 2240 * 2241 * <p> 2242 * 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. 2243 * </p> 2244 * 2245 * @param companyId the company ID 2246 * @param parentGroupId the parent group ID 2247 * @param site the site 2248 * @param start the lower bound of the range of groups 2249 * @param end the upper bound of the range of groups (not inclusive) 2250 * @return the range of matching groups 2251 * @throws SystemException if a system exception occurred 2252 */ 2253 public static java.util.List<com.liferay.portal.model.Group> findByC_P_S( 2254 long companyId, long parentGroupId, boolean site, int start, int end) 2255 throws com.liferay.portal.kernel.exception.SystemException { 2256 return getPersistence() 2257 .findByC_P_S(companyId, parentGroupId, site, start, end); 2258 } 2259 2260 /** 2261 * Returns an ordered range of all the groups where companyId = ? and parentGroupId = ? and site = ?. 2262 * 2263 * <p> 2264 * 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. 2265 * </p> 2266 * 2267 * @param companyId the company ID 2268 * @param parentGroupId the parent group ID 2269 * @param site the site 2270 * @param start the lower bound of the range of groups 2271 * @param end the upper bound of the range of groups (not inclusive) 2272 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2273 * @return the ordered range of matching groups 2274 * @throws SystemException if a system exception occurred 2275 */ 2276 public static java.util.List<com.liferay.portal.model.Group> findByC_P_S( 2277 long companyId, long parentGroupId, boolean site, int start, int end, 2278 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2279 throws com.liferay.portal.kernel.exception.SystemException { 2280 return getPersistence() 2281 .findByC_P_S(companyId, parentGroupId, site, start, end, 2282 orderByComparator); 2283 } 2284 2285 /** 2286 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 2287 * 2288 * @param companyId the company ID 2289 * @param parentGroupId the parent group ID 2290 * @param site the site 2291 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2292 * @return the first matching group 2293 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 2294 * @throws SystemException if a system exception occurred 2295 */ 2296 public static com.liferay.portal.model.Group findByC_P_S_First( 2297 long companyId, long parentGroupId, boolean site, 2298 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2299 throws com.liferay.portal.NoSuchGroupException, 2300 com.liferay.portal.kernel.exception.SystemException { 2301 return getPersistence() 2302 .findByC_P_S_First(companyId, parentGroupId, site, 2303 orderByComparator); 2304 } 2305 2306 /** 2307 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 2308 * 2309 * @param companyId the company ID 2310 * @param parentGroupId the parent group ID 2311 * @param site the site 2312 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2313 * @return the first matching group, or <code>null</code> if a matching group could not be found 2314 * @throws SystemException if a system exception occurred 2315 */ 2316 public static com.liferay.portal.model.Group fetchByC_P_S_First( 2317 long companyId, long parentGroupId, boolean site, 2318 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2319 throws com.liferay.portal.kernel.exception.SystemException { 2320 return getPersistence() 2321 .fetchByC_P_S_First(companyId, parentGroupId, site, 2322 orderByComparator); 2323 } 2324 2325 /** 2326 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 2327 * 2328 * @param companyId the company ID 2329 * @param parentGroupId the parent group ID 2330 * @param site the site 2331 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2332 * @return the last matching group 2333 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 2334 * @throws SystemException if a system exception occurred 2335 */ 2336 public static com.liferay.portal.model.Group findByC_P_S_Last( 2337 long companyId, long parentGroupId, boolean site, 2338 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2339 throws com.liferay.portal.NoSuchGroupException, 2340 com.liferay.portal.kernel.exception.SystemException { 2341 return getPersistence() 2342 .findByC_P_S_Last(companyId, parentGroupId, site, 2343 orderByComparator); 2344 } 2345 2346 /** 2347 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 2348 * 2349 * @param companyId the company ID 2350 * @param parentGroupId the parent group ID 2351 * @param site the site 2352 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2353 * @return the last matching group, or <code>null</code> if a matching group could not be found 2354 * @throws SystemException if a system exception occurred 2355 */ 2356 public static com.liferay.portal.model.Group fetchByC_P_S_Last( 2357 long companyId, long parentGroupId, boolean site, 2358 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2359 throws com.liferay.portal.kernel.exception.SystemException { 2360 return getPersistence() 2361 .fetchByC_P_S_Last(companyId, parentGroupId, site, 2362 orderByComparator); 2363 } 2364 2365 /** 2366 * Returns the groups before and after the current group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 2367 * 2368 * @param groupId the primary key of the current group 2369 * @param companyId the company ID 2370 * @param parentGroupId the parent group ID 2371 * @param site the site 2372 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2373 * @return the previous, current, and next group 2374 * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found 2375 * @throws SystemException if a system exception occurred 2376 */ 2377 public static com.liferay.portal.model.Group[] findByC_P_S_PrevAndNext( 2378 long groupId, long companyId, long parentGroupId, boolean site, 2379 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2380 throws com.liferay.portal.NoSuchGroupException, 2381 com.liferay.portal.kernel.exception.SystemException { 2382 return getPersistence() 2383 .findByC_P_S_PrevAndNext(groupId, companyId, parentGroupId, 2384 site, orderByComparator); 2385 } 2386 2387 /** 2388 * Removes all the groups where companyId = ? and parentGroupId = ? and site = ? from the database. 2389 * 2390 * @param companyId the company ID 2391 * @param parentGroupId the parent group ID 2392 * @param site the site 2393 * @throws SystemException if a system exception occurred 2394 */ 2395 public static void removeByC_P_S(long companyId, long parentGroupId, 2396 boolean site) 2397 throws com.liferay.portal.kernel.exception.SystemException { 2398 getPersistence().removeByC_P_S(companyId, parentGroupId, site); 2399 } 2400 2401 /** 2402 * Returns the number of groups where companyId = ? and parentGroupId = ? and site = ?. 2403 * 2404 * @param companyId the company ID 2405 * @param parentGroupId the parent group ID 2406 * @param site the site 2407 * @return the number of matching groups 2408 * @throws SystemException if a system exception occurred 2409 */ 2410 public static int countByC_P_S(long companyId, long parentGroupId, 2411 boolean site) 2412 throws com.liferay.portal.kernel.exception.SystemException { 2413 return getPersistence().countByC_P_S(companyId, parentGroupId, site); 2414 } 2415 2416 /** 2417 * Returns the group where companyId = ? and liveGroupId = ? and name = ? or throws a {@link com.liferay.portal.NoSuchGroupException} if it could not be found. 2418 * 2419 * @param companyId the company ID 2420 * @param liveGroupId the live group ID 2421 * @param name the name 2422 * @return the matching group 2423 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 2424 * @throws SystemException if a system exception occurred 2425 */ 2426 public static com.liferay.portal.model.Group findByC_L_N(long companyId, 2427 long liveGroupId, java.lang.String name) 2428 throws com.liferay.portal.NoSuchGroupException, 2429 com.liferay.portal.kernel.exception.SystemException { 2430 return getPersistence().findByC_L_N(companyId, liveGroupId, name); 2431 } 2432 2433 /** 2434 * Returns the group where companyId = ? and liveGroupId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2435 * 2436 * @param companyId the company ID 2437 * @param liveGroupId the live group ID 2438 * @param name the name 2439 * @return the matching group, or <code>null</code> if a matching group could not be found 2440 * @throws SystemException if a system exception occurred 2441 */ 2442 public static com.liferay.portal.model.Group fetchByC_L_N(long companyId, 2443 long liveGroupId, java.lang.String name) 2444 throws com.liferay.portal.kernel.exception.SystemException { 2445 return getPersistence().fetchByC_L_N(companyId, liveGroupId, name); 2446 } 2447 2448 /** 2449 * 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. 2450 * 2451 * @param companyId the company ID 2452 * @param liveGroupId the live group ID 2453 * @param name the name 2454 * @param retrieveFromCache whether to use the finder cache 2455 * @return the matching group, or <code>null</code> if a matching group could not be found 2456 * @throws SystemException if a system exception occurred 2457 */ 2458 public static com.liferay.portal.model.Group fetchByC_L_N(long companyId, 2459 long liveGroupId, java.lang.String name, boolean retrieveFromCache) 2460 throws com.liferay.portal.kernel.exception.SystemException { 2461 return getPersistence() 2462 .fetchByC_L_N(companyId, liveGroupId, name, retrieveFromCache); 2463 } 2464 2465 /** 2466 * Removes the group where companyId = ? and liveGroupId = ? and name = ? from the database. 2467 * 2468 * @param companyId the company ID 2469 * @param liveGroupId the live group ID 2470 * @param name the name 2471 * @return the group that was removed 2472 * @throws SystemException if a system exception occurred 2473 */ 2474 public static com.liferay.portal.model.Group removeByC_L_N(long companyId, 2475 long liveGroupId, java.lang.String name) 2476 throws com.liferay.portal.NoSuchGroupException, 2477 com.liferay.portal.kernel.exception.SystemException { 2478 return getPersistence().removeByC_L_N(companyId, liveGroupId, name); 2479 } 2480 2481 /** 2482 * Returns the number of groups where companyId = ? and liveGroupId = ? and name = ?. 2483 * 2484 * @param companyId the company ID 2485 * @param liveGroupId the live group ID 2486 * @param name the name 2487 * @return the number of matching groups 2488 * @throws SystemException if a system exception occurred 2489 */ 2490 public static int countByC_L_N(long companyId, long liveGroupId, 2491 java.lang.String name) 2492 throws com.liferay.portal.kernel.exception.SystemException { 2493 return getPersistence().countByC_L_N(companyId, liveGroupId, name); 2494 } 2495 2496 /** 2497 * 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. 2498 * 2499 * @param companyId the company ID 2500 * @param classNameId the class name ID 2501 * @param liveGroupId the live group ID 2502 * @param name the name 2503 * @return the matching group 2504 * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found 2505 * @throws SystemException if a system exception occurred 2506 */ 2507 public static com.liferay.portal.model.Group findByC_C_L_N(long companyId, 2508 long classNameId, long liveGroupId, java.lang.String name) 2509 throws com.liferay.portal.NoSuchGroupException, 2510 com.liferay.portal.kernel.exception.SystemException { 2511 return getPersistence() 2512 .findByC_C_L_N(companyId, classNameId, liveGroupId, name); 2513 } 2514 2515 /** 2516 * 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. 2517 * 2518 * @param companyId the company ID 2519 * @param classNameId the class name ID 2520 * @param liveGroupId the live group ID 2521 * @param name the name 2522 * @return the matching group, or <code>null</code> if a matching group could not be found 2523 * @throws SystemException if a system exception occurred 2524 */ 2525 public static com.liferay.portal.model.Group fetchByC_C_L_N( 2526 long companyId, long classNameId, long liveGroupId, 2527 java.lang.String name) 2528 throws com.liferay.portal.kernel.exception.SystemException { 2529 return getPersistence() 2530 .fetchByC_C_L_N(companyId, classNameId, liveGroupId, name); 2531 } 2532 2533 /** 2534 * 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. 2535 * 2536 * @param companyId the company ID 2537 * @param classNameId the class name ID 2538 * @param liveGroupId the live group ID 2539 * @param name the name 2540 * @param retrieveFromCache whether to use the finder cache 2541 * @return the matching group, or <code>null</code> if a matching group could not be found 2542 * @throws SystemException if a system exception occurred 2543 */ 2544 public static com.liferay.portal.model.Group fetchByC_C_L_N( 2545 long companyId, long classNameId, long liveGroupId, 2546 java.lang.String name, boolean retrieveFromCache) 2547 throws com.liferay.portal.kernel.exception.SystemException { 2548 return getPersistence() 2549 .fetchByC_C_L_N(companyId, classNameId, liveGroupId, name, 2550 retrieveFromCache); 2551 } 2552 2553 /** 2554 * Removes the group where companyId = ? and classNameId = ? and liveGroupId = ? and name = ? from the database. 2555 * 2556 * @param companyId the company ID 2557 * @param classNameId the class name ID 2558 * @param liveGroupId the live group ID 2559 * @param name the name 2560 * @return the group that was removed 2561 * @throws SystemException if a system exception occurred 2562 */ 2563 public static com.liferay.portal.model.Group removeByC_C_L_N( 2564 long companyId, long classNameId, long liveGroupId, 2565 java.lang.String name) 2566 throws com.liferay.portal.NoSuchGroupException, 2567 com.liferay.portal.kernel.exception.SystemException { 2568 return getPersistence() 2569 .removeByC_C_L_N(companyId, classNameId, liveGroupId, name); 2570 } 2571 2572 /** 2573 * Returns the number of groups where companyId = ? and classNameId = ? and liveGroupId = ? and name = ?. 2574 * 2575 * @param companyId the company ID 2576 * @param classNameId the class name ID 2577 * @param liveGroupId the live group ID 2578 * @param name the name 2579 * @return the number of matching groups 2580 * @throws SystemException if a system exception occurred 2581 */ 2582 public static int countByC_C_L_N(long companyId, long classNameId, 2583 long liveGroupId, java.lang.String name) 2584 throws com.liferay.portal.kernel.exception.SystemException { 2585 return getPersistence() 2586 .countByC_C_L_N(companyId, classNameId, liveGroupId, name); 2587 } 2588 2589 /** 2590 * Caches the group in the entity cache if it is enabled. 2591 * 2592 * @param group the group 2593 */ 2594 public static void cacheResult(com.liferay.portal.model.Group group) { 2595 getPersistence().cacheResult(group); 2596 } 2597 2598 /** 2599 * Caches the groups in the entity cache if it is enabled. 2600 * 2601 * @param groups the groups 2602 */ 2603 public static void cacheResult( 2604 java.util.List<com.liferay.portal.model.Group> groups) { 2605 getPersistence().cacheResult(groups); 2606 } 2607 2608 /** 2609 * Creates a new group with the primary key. Does not add the group to the database. 2610 * 2611 * @param groupId the primary key for the new group 2612 * @return the new group 2613 */ 2614 public static com.liferay.portal.model.Group create(long groupId) { 2615 return getPersistence().create(groupId); 2616 } 2617 2618 /** 2619 * Removes the group with the primary key from the database. Also notifies the appropriate model listeners. 2620 * 2621 * @param groupId the primary key of the group 2622 * @return the group that was removed 2623 * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found 2624 * @throws SystemException if a system exception occurred 2625 */ 2626 public static com.liferay.portal.model.Group remove(long groupId) 2627 throws com.liferay.portal.NoSuchGroupException, 2628 com.liferay.portal.kernel.exception.SystemException { 2629 return getPersistence().remove(groupId); 2630 } 2631 2632 public static com.liferay.portal.model.Group updateImpl( 2633 com.liferay.portal.model.Group group) 2634 throws com.liferay.portal.kernel.exception.SystemException { 2635 return getPersistence().updateImpl(group); 2636 } 2637 2638 /** 2639 * Returns the group with the primary key or throws a {@link com.liferay.portal.NoSuchGroupException} if it could not be found. 2640 * 2641 * @param groupId the primary key of the group 2642 * @return the group 2643 * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found 2644 * @throws SystemException if a system exception occurred 2645 */ 2646 public static com.liferay.portal.model.Group findByPrimaryKey(long groupId) 2647 throws com.liferay.portal.NoSuchGroupException, 2648 com.liferay.portal.kernel.exception.SystemException { 2649 return getPersistence().findByPrimaryKey(groupId); 2650 } 2651 2652 /** 2653 * Returns the group with the primary key or returns <code>null</code> if it could not be found. 2654 * 2655 * @param groupId the primary key of the group 2656 * @return the group, or <code>null</code> if a group with the primary key could not be found 2657 * @throws SystemException if a system exception occurred 2658 */ 2659 public static com.liferay.portal.model.Group fetchByPrimaryKey(long groupId) 2660 throws com.liferay.portal.kernel.exception.SystemException { 2661 return getPersistence().fetchByPrimaryKey(groupId); 2662 } 2663 2664 /** 2665 * Returns all the groups. 2666 * 2667 * @return the groups 2668 * @throws SystemException if a system exception occurred 2669 */ 2670 public static java.util.List<com.liferay.portal.model.Group> findAll() 2671 throws com.liferay.portal.kernel.exception.SystemException { 2672 return getPersistence().findAll(); 2673 } 2674 2675 /** 2676 * Returns a range of all the groups. 2677 * 2678 * <p> 2679 * 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. 2680 * </p> 2681 * 2682 * @param start the lower bound of the range of groups 2683 * @param end the upper bound of the range of groups (not inclusive) 2684 * @return the range of groups 2685 * @throws SystemException if a system exception occurred 2686 */ 2687 public static java.util.List<com.liferay.portal.model.Group> findAll( 2688 int start, int end) 2689 throws com.liferay.portal.kernel.exception.SystemException { 2690 return getPersistence().findAll(start, end); 2691 } 2692 2693 /** 2694 * Returns an ordered range of all the groups. 2695 * 2696 * <p> 2697 * 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. 2698 * </p> 2699 * 2700 * @param start the lower bound of the range of groups 2701 * @param end the upper bound of the range of groups (not inclusive) 2702 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2703 * @return the ordered range of groups 2704 * @throws SystemException if a system exception occurred 2705 */ 2706 public static java.util.List<com.liferay.portal.model.Group> findAll( 2707 int start, int end, 2708 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2709 throws com.liferay.portal.kernel.exception.SystemException { 2710 return getPersistence().findAll(start, end, orderByComparator); 2711 } 2712 2713 /** 2714 * Removes all the groups from the database. 2715 * 2716 * @throws SystemException if a system exception occurred 2717 */ 2718 public static void removeAll() 2719 throws com.liferay.portal.kernel.exception.SystemException { 2720 getPersistence().removeAll(); 2721 } 2722 2723 /** 2724 * Returns the number of groups. 2725 * 2726 * @return the number of groups 2727 * @throws SystemException if a system exception occurred 2728 */ 2729 public static int countAll() 2730 throws com.liferay.portal.kernel.exception.SystemException { 2731 return getPersistence().countAll(); 2732 } 2733 2734 /** 2735 * Returns all the organizations associated with the group. 2736 * 2737 * @param pk the primary key of the group 2738 * @return the organizations associated with the group 2739 * @throws SystemException if a system exception occurred 2740 */ 2741 public static java.util.List<com.liferay.portal.model.Organization> getOrganizations( 2742 long pk) throws com.liferay.portal.kernel.exception.SystemException { 2743 return getPersistence().getOrganizations(pk); 2744 } 2745 2746 /** 2747 * Returns a range of all the organizations associated with the group. 2748 * 2749 * <p> 2750 * 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. 2751 * </p> 2752 * 2753 * @param pk the primary key of the group 2754 * @param start the lower bound of the range of groups 2755 * @param end the upper bound of the range of groups (not inclusive) 2756 * @return the range of organizations associated with the group 2757 * @throws SystemException if a system exception occurred 2758 */ 2759 public static java.util.List<com.liferay.portal.model.Organization> getOrganizations( 2760 long pk, int start, int end) 2761 throws com.liferay.portal.kernel.exception.SystemException { 2762 return getPersistence().getOrganizations(pk, start, end); 2763 } 2764 2765 /** 2766 * Returns an ordered range of all the organizations associated with the group. 2767 * 2768 * <p> 2769 * 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. 2770 * </p> 2771 * 2772 * @param pk the primary key of the group 2773 * @param start the lower bound of the range of groups 2774 * @param end the upper bound of the range of groups (not inclusive) 2775 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2776 * @return the ordered range of organizations associated with the group 2777 * @throws SystemException if a system exception occurred 2778 */ 2779 public static java.util.List<com.liferay.portal.model.Organization> getOrganizations( 2780 long pk, int start, int end, 2781 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2782 throws com.liferay.portal.kernel.exception.SystemException { 2783 return getPersistence() 2784 .getOrganizations(pk, start, end, orderByComparator); 2785 } 2786 2787 /** 2788 * Returns the number of organizations associated with the group. 2789 * 2790 * @param pk the primary key of the group 2791 * @return the number of organizations associated with the group 2792 * @throws SystemException if a system exception occurred 2793 */ 2794 public static int getOrganizationsSize(long pk) 2795 throws com.liferay.portal.kernel.exception.SystemException { 2796 return getPersistence().getOrganizationsSize(pk); 2797 } 2798 2799 /** 2800 * Returns <code>true</code> if the organization is associated with the group. 2801 * 2802 * @param pk the primary key of the group 2803 * @param organizationPK the primary key of the organization 2804 * @return <code>true</code> if the organization is associated with the group; <code>false</code> otherwise 2805 * @throws SystemException if a system exception occurred 2806 */ 2807 public static boolean containsOrganization(long pk, long organizationPK) 2808 throws com.liferay.portal.kernel.exception.SystemException { 2809 return getPersistence().containsOrganization(pk, organizationPK); 2810 } 2811 2812 /** 2813 * Returns <code>true</code> if the group has any organizations associated with it. 2814 * 2815 * @param pk the primary key of the group to check for associations with organizations 2816 * @return <code>true</code> if the group has any organizations associated with it; <code>false</code> otherwise 2817 * @throws SystemException if a system exception occurred 2818 */ 2819 public static boolean containsOrganizations(long pk) 2820 throws com.liferay.portal.kernel.exception.SystemException { 2821 return getPersistence().containsOrganizations(pk); 2822 } 2823 2824 /** 2825 * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2826 * 2827 * @param pk the primary key of the group 2828 * @param organizationPK the primary key of the organization 2829 * @throws SystemException if a system exception occurred 2830 */ 2831 public static void addOrganization(long pk, long organizationPK) 2832 throws com.liferay.portal.kernel.exception.SystemException { 2833 getPersistence().addOrganization(pk, organizationPK); 2834 } 2835 2836 /** 2837 * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2838 * 2839 * @param pk the primary key of the group 2840 * @param organization the organization 2841 * @throws SystemException if a system exception occurred 2842 */ 2843 public static void addOrganization(long pk, 2844 com.liferay.portal.model.Organization organization) 2845 throws com.liferay.portal.kernel.exception.SystemException { 2846 getPersistence().addOrganization(pk, organization); 2847 } 2848 2849 /** 2850 * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2851 * 2852 * @param pk the primary key of the group 2853 * @param organizationPKs the primary keys of the organizations 2854 * @throws SystemException if a system exception occurred 2855 */ 2856 public static void addOrganizations(long pk, long[] organizationPKs) 2857 throws com.liferay.portal.kernel.exception.SystemException { 2858 getPersistence().addOrganizations(pk, organizationPKs); 2859 } 2860 2861 /** 2862 * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2863 * 2864 * @param pk the primary key of the group 2865 * @param organizations the organizations 2866 * @throws SystemException if a system exception occurred 2867 */ 2868 public static void addOrganizations(long pk, 2869 java.util.List<com.liferay.portal.model.Organization> organizations) 2870 throws com.liferay.portal.kernel.exception.SystemException { 2871 getPersistence().addOrganizations(pk, organizations); 2872 } 2873 2874 /** 2875 * Clears all associations between the group and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2876 * 2877 * @param pk the primary key of the group to clear the associated organizations from 2878 * @throws SystemException if a system exception occurred 2879 */ 2880 public static void clearOrganizations(long pk) 2881 throws com.liferay.portal.kernel.exception.SystemException { 2882 getPersistence().clearOrganizations(pk); 2883 } 2884 2885 /** 2886 * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2887 * 2888 * @param pk the primary key of the group 2889 * @param organizationPK the primary key of the organization 2890 * @throws SystemException if a system exception occurred 2891 */ 2892 public static void removeOrganization(long pk, long organizationPK) 2893 throws com.liferay.portal.kernel.exception.SystemException { 2894 getPersistence().removeOrganization(pk, organizationPK); 2895 } 2896 2897 /** 2898 * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2899 * 2900 * @param pk the primary key of the group 2901 * @param organization the organization 2902 * @throws SystemException if a system exception occurred 2903 */ 2904 public static void removeOrganization(long pk, 2905 com.liferay.portal.model.Organization organization) 2906 throws com.liferay.portal.kernel.exception.SystemException { 2907 getPersistence().removeOrganization(pk, organization); 2908 } 2909 2910 /** 2911 * Removes the association between the group and the organizations. 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 organizationPKs the primary keys of the organizations 2915 * @throws SystemException if a system exception occurred 2916 */ 2917 public static void removeOrganizations(long pk, long[] organizationPKs) 2918 throws com.liferay.portal.kernel.exception.SystemException { 2919 getPersistence().removeOrganizations(pk, organizationPKs); 2920 } 2921 2922 /** 2923 * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2924 * 2925 * @param pk the primary key of the group 2926 * @param organizations the organizations 2927 * @throws SystemException if a system exception occurred 2928 */ 2929 public static void removeOrganizations(long pk, 2930 java.util.List<com.liferay.portal.model.Organization> organizations) 2931 throws com.liferay.portal.kernel.exception.SystemException { 2932 getPersistence().removeOrganizations(pk, organizations); 2933 } 2934 2935 /** 2936 * 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. 2937 * 2938 * @param pk the primary key of the group 2939 * @param organizationPKs the primary keys of the organizations to be associated with the group 2940 * @throws SystemException if a system exception occurred 2941 */ 2942 public static void setOrganizations(long pk, long[] organizationPKs) 2943 throws com.liferay.portal.kernel.exception.SystemException { 2944 getPersistence().setOrganizations(pk, organizationPKs); 2945 } 2946 2947 /** 2948 * 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. 2949 * 2950 * @param pk the primary key of the group 2951 * @param organizations the organizations to be associated with the group 2952 * @throws SystemException if a system exception occurred 2953 */ 2954 public static void setOrganizations(long pk, 2955 java.util.List<com.liferay.portal.model.Organization> organizations) 2956 throws com.liferay.portal.kernel.exception.SystemException { 2957 getPersistence().setOrganizations(pk, organizations); 2958 } 2959 2960 /** 2961 * Returns all the roles associated with the group. 2962 * 2963 * @param pk the primary key of the group 2964 * @return the roles associated with the group 2965 * @throws SystemException if a system exception occurred 2966 */ 2967 public static java.util.List<com.liferay.portal.model.Role> getRoles( 2968 long pk) throws com.liferay.portal.kernel.exception.SystemException { 2969 return getPersistence().getRoles(pk); 2970 } 2971 2972 /** 2973 * Returns a range of all the roles associated with the group. 2974 * 2975 * <p> 2976 * 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. 2977 * </p> 2978 * 2979 * @param pk the primary key of the group 2980 * @param start the lower bound of the range of groups 2981 * @param end the upper bound of the range of groups (not inclusive) 2982 * @return the range of roles associated with the group 2983 * @throws SystemException if a system exception occurred 2984 */ 2985 public static java.util.List<com.liferay.portal.model.Role> getRoles( 2986 long pk, int start, int end) 2987 throws com.liferay.portal.kernel.exception.SystemException { 2988 return getPersistence().getRoles(pk, start, end); 2989 } 2990 2991 /** 2992 * Returns an ordered range of all the roles associated with the group. 2993 * 2994 * <p> 2995 * 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. 2996 * </p> 2997 * 2998 * @param pk the primary key of the group 2999 * @param start the lower bound of the range of groups 3000 * @param end the upper bound of the range of groups (not inclusive) 3001 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3002 * @return the ordered range of roles associated with the group 3003 * @throws SystemException if a system exception occurred 3004 */ 3005 public static java.util.List<com.liferay.portal.model.Role> getRoles( 3006 long pk, int start, int end, 3007 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3008 throws com.liferay.portal.kernel.exception.SystemException { 3009 return getPersistence().getRoles(pk, start, end, orderByComparator); 3010 } 3011 3012 /** 3013 * Returns the number of roles associated with the group. 3014 * 3015 * @param pk the primary key of the group 3016 * @return the number of roles associated with the group 3017 * @throws SystemException if a system exception occurred 3018 */ 3019 public static int getRolesSize(long pk) 3020 throws com.liferay.portal.kernel.exception.SystemException { 3021 return getPersistence().getRolesSize(pk); 3022 } 3023 3024 /** 3025 * Returns <code>true</code> if the role is associated with the group. 3026 * 3027 * @param pk the primary key of the group 3028 * @param rolePK the primary key of the role 3029 * @return <code>true</code> if the role is associated with the group; <code>false</code> otherwise 3030 * @throws SystemException if a system exception occurred 3031 */ 3032 public static boolean containsRole(long pk, long rolePK) 3033 throws com.liferay.portal.kernel.exception.SystemException { 3034 return getPersistence().containsRole(pk, rolePK); 3035 } 3036 3037 /** 3038 * Returns <code>true</code> if the group has any roles associated with it. 3039 * 3040 * @param pk the primary key of the group to check for associations with roles 3041 * @return <code>true</code> if the group has any roles associated with it; <code>false</code> otherwise 3042 * @throws SystemException if a system exception occurred 3043 */ 3044 public static boolean containsRoles(long pk) 3045 throws com.liferay.portal.kernel.exception.SystemException { 3046 return getPersistence().containsRoles(pk); 3047 } 3048 3049 /** 3050 * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3051 * 3052 * @param pk the primary key of the group 3053 * @param rolePK the primary key of the role 3054 * @throws SystemException if a system exception occurred 3055 */ 3056 public static void addRole(long pk, long rolePK) 3057 throws com.liferay.portal.kernel.exception.SystemException { 3058 getPersistence().addRole(pk, rolePK); 3059 } 3060 3061 /** 3062 * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3063 * 3064 * @param pk the primary key of the group 3065 * @param role the role 3066 * @throws SystemException if a system exception occurred 3067 */ 3068 public static void addRole(long pk, com.liferay.portal.model.Role role) 3069 throws com.liferay.portal.kernel.exception.SystemException { 3070 getPersistence().addRole(pk, role); 3071 } 3072 3073 /** 3074 * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3075 * 3076 * @param pk the primary key of the group 3077 * @param rolePKs the primary keys of the roles 3078 * @throws SystemException if a system exception occurred 3079 */ 3080 public static void addRoles(long pk, long[] rolePKs) 3081 throws com.liferay.portal.kernel.exception.SystemException { 3082 getPersistence().addRoles(pk, rolePKs); 3083 } 3084 3085 /** 3086 * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3087 * 3088 * @param pk the primary key of the group 3089 * @param roles the roles 3090 * @throws SystemException if a system exception occurred 3091 */ 3092 public static void addRoles(long pk, 3093 java.util.List<com.liferay.portal.model.Role> roles) 3094 throws com.liferay.portal.kernel.exception.SystemException { 3095 getPersistence().addRoles(pk, roles); 3096 } 3097 3098 /** 3099 * Clears all associations between the group and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3100 * 3101 * @param pk the primary key of the group to clear the associated roles from 3102 * @throws SystemException if a system exception occurred 3103 */ 3104 public static void clearRoles(long pk) 3105 throws com.liferay.portal.kernel.exception.SystemException { 3106 getPersistence().clearRoles(pk); 3107 } 3108 3109 /** 3110 * Removes the association between the group and the role. 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 rolePK the primary key of the role 3114 * @throws SystemException if a system exception occurred 3115 */ 3116 public static void removeRole(long pk, long rolePK) 3117 throws com.liferay.portal.kernel.exception.SystemException { 3118 getPersistence().removeRole(pk, rolePK); 3119 } 3120 3121 /** 3122 * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3123 * 3124 * @param pk the primary key of the group 3125 * @param role the role 3126 * @throws SystemException if a system exception occurred 3127 */ 3128 public static void removeRole(long pk, com.liferay.portal.model.Role role) 3129 throws com.liferay.portal.kernel.exception.SystemException { 3130 getPersistence().removeRole(pk, role); 3131 } 3132 3133 /** 3134 * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3135 * 3136 * @param pk the primary key of the group 3137 * @param rolePKs the primary keys of the roles 3138 * @throws SystemException if a system exception occurred 3139 */ 3140 public static void removeRoles(long pk, long[] rolePKs) 3141 throws com.liferay.portal.kernel.exception.SystemException { 3142 getPersistence().removeRoles(pk, rolePKs); 3143 } 3144 3145 /** 3146 * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3147 * 3148 * @param pk the primary key of the group 3149 * @param roles the roles 3150 * @throws SystemException if a system exception occurred 3151 */ 3152 public static void removeRoles(long pk, 3153 java.util.List<com.liferay.portal.model.Role> roles) 3154 throws com.liferay.portal.kernel.exception.SystemException { 3155 getPersistence().removeRoles(pk, roles); 3156 } 3157 3158 /** 3159 * 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. 3160 * 3161 * @param pk the primary key of the group 3162 * @param rolePKs the primary keys of the roles to be associated with the group 3163 * @throws SystemException if a system exception occurred 3164 */ 3165 public static void setRoles(long pk, long[] rolePKs) 3166 throws com.liferay.portal.kernel.exception.SystemException { 3167 getPersistence().setRoles(pk, rolePKs); 3168 } 3169 3170 /** 3171 * 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. 3172 * 3173 * @param pk the primary key of the group 3174 * @param roles the roles to be associated with the group 3175 * @throws SystemException if a system exception occurred 3176 */ 3177 public static void setRoles(long pk, 3178 java.util.List<com.liferay.portal.model.Role> roles) 3179 throws com.liferay.portal.kernel.exception.SystemException { 3180 getPersistence().setRoles(pk, roles); 3181 } 3182 3183 /** 3184 * Returns all the user groups associated with the group. 3185 * 3186 * @param pk the primary key of the group 3187 * @return the user groups associated with the group 3188 * @throws SystemException if a system exception occurred 3189 */ 3190 public static java.util.List<com.liferay.portal.model.UserGroup> getUserGroups( 3191 long pk) throws com.liferay.portal.kernel.exception.SystemException { 3192 return getPersistence().getUserGroups(pk); 3193 } 3194 3195 /** 3196 * Returns a range of all the user groups associated with the group. 3197 * 3198 * <p> 3199 * 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. 3200 * </p> 3201 * 3202 * @param pk the primary key of the group 3203 * @param start the lower bound of the range of groups 3204 * @param end the upper bound of the range of groups (not inclusive) 3205 * @return the range of user groups associated with the group 3206 * @throws SystemException if a system exception occurred 3207 */ 3208 public static java.util.List<com.liferay.portal.model.UserGroup> getUserGroups( 3209 long pk, int start, int end) 3210 throws com.liferay.portal.kernel.exception.SystemException { 3211 return getPersistence().getUserGroups(pk, start, end); 3212 } 3213 3214 /** 3215 * Returns an ordered range of all the user groups associated with the group. 3216 * 3217 * <p> 3218 * 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. 3219 * </p> 3220 * 3221 * @param pk the primary key of the group 3222 * @param start the lower bound of the range of groups 3223 * @param end the upper bound of the range of groups (not inclusive) 3224 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3225 * @return the ordered range of user groups associated with the group 3226 * @throws SystemException if a system exception occurred 3227 */ 3228 public static java.util.List<com.liferay.portal.model.UserGroup> getUserGroups( 3229 long pk, int start, int end, 3230 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3231 throws com.liferay.portal.kernel.exception.SystemException { 3232 return getPersistence().getUserGroups(pk, start, end, orderByComparator); 3233 } 3234 3235 /** 3236 * Returns the number of user groups associated with the group. 3237 * 3238 * @param pk the primary key of the group 3239 * @return the number of user groups associated with the group 3240 * @throws SystemException if a system exception occurred 3241 */ 3242 public static int getUserGroupsSize(long pk) 3243 throws com.liferay.portal.kernel.exception.SystemException { 3244 return getPersistence().getUserGroupsSize(pk); 3245 } 3246 3247 /** 3248 * Returns <code>true</code> if the user group is associated with the group. 3249 * 3250 * @param pk the primary key of the group 3251 * @param userGroupPK the primary key of the user group 3252 * @return <code>true</code> if the user group is associated with the group; <code>false</code> otherwise 3253 * @throws SystemException if a system exception occurred 3254 */ 3255 public static boolean containsUserGroup(long pk, long userGroupPK) 3256 throws com.liferay.portal.kernel.exception.SystemException { 3257 return getPersistence().containsUserGroup(pk, userGroupPK); 3258 } 3259 3260 /** 3261 * Returns <code>true</code> if the group has any user groups associated with it. 3262 * 3263 * @param pk the primary key of the group to check for associations with user groups 3264 * @return <code>true</code> if the group has any user groups associated with it; <code>false</code> otherwise 3265 * @throws SystemException if a system exception occurred 3266 */ 3267 public static boolean containsUserGroups(long pk) 3268 throws com.liferay.portal.kernel.exception.SystemException { 3269 return getPersistence().containsUserGroups(pk); 3270 } 3271 3272 /** 3273 * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3274 * 3275 * @param pk the primary key of the group 3276 * @param userGroupPK the primary key of the user group 3277 * @throws SystemException if a system exception occurred 3278 */ 3279 public static void addUserGroup(long pk, long userGroupPK) 3280 throws com.liferay.portal.kernel.exception.SystemException { 3281 getPersistence().addUserGroup(pk, userGroupPK); 3282 } 3283 3284 /** 3285 * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3286 * 3287 * @param pk the primary key of the group 3288 * @param userGroup the user group 3289 * @throws SystemException if a system exception occurred 3290 */ 3291 public static void addUserGroup(long pk, 3292 com.liferay.portal.model.UserGroup userGroup) 3293 throws com.liferay.portal.kernel.exception.SystemException { 3294 getPersistence().addUserGroup(pk, userGroup); 3295 } 3296 3297 /** 3298 * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3299 * 3300 * @param pk the primary key of the group 3301 * @param userGroupPKs the primary keys of the user groups 3302 * @throws SystemException if a system exception occurred 3303 */ 3304 public static void addUserGroups(long pk, long[] userGroupPKs) 3305 throws com.liferay.portal.kernel.exception.SystemException { 3306 getPersistence().addUserGroups(pk, userGroupPKs); 3307 } 3308 3309 /** 3310 * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3311 * 3312 * @param pk the primary key of the group 3313 * @param userGroups the user groups 3314 * @throws SystemException if a system exception occurred 3315 */ 3316 public static void addUserGroups(long pk, 3317 java.util.List<com.liferay.portal.model.UserGroup> userGroups) 3318 throws com.liferay.portal.kernel.exception.SystemException { 3319 getPersistence().addUserGroups(pk, userGroups); 3320 } 3321 3322 /** 3323 * Clears all associations between the group and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3324 * 3325 * @param pk the primary key of the group to clear the associated user groups from 3326 * @throws SystemException if a system exception occurred 3327 */ 3328 public static void clearUserGroups(long pk) 3329 throws com.liferay.portal.kernel.exception.SystemException { 3330 getPersistence().clearUserGroups(pk); 3331 } 3332 3333 /** 3334 * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3335 * 3336 * @param pk the primary key of the group 3337 * @param userGroupPK the primary key of the user group 3338 * @throws SystemException if a system exception occurred 3339 */ 3340 public static void removeUserGroup(long pk, long userGroupPK) 3341 throws com.liferay.portal.kernel.exception.SystemException { 3342 getPersistence().removeUserGroup(pk, userGroupPK); 3343 } 3344 3345 /** 3346 * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3347 * 3348 * @param pk the primary key of the group 3349 * @param userGroup the user group 3350 * @throws SystemException if a system exception occurred 3351 */ 3352 public static void removeUserGroup(long pk, 3353 com.liferay.portal.model.UserGroup userGroup) 3354 throws com.liferay.portal.kernel.exception.SystemException { 3355 getPersistence().removeUserGroup(pk, userGroup); 3356 } 3357 3358 /** 3359 * Removes the association between the group and the user groups. 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 userGroupPKs the primary keys of the user groups 3363 * @throws SystemException if a system exception occurred 3364 */ 3365 public static void removeUserGroups(long pk, long[] userGroupPKs) 3366 throws com.liferay.portal.kernel.exception.SystemException { 3367 getPersistence().removeUserGroups(pk, userGroupPKs); 3368 } 3369 3370 /** 3371 * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3372 * 3373 * @param pk the primary key of the group 3374 * @param userGroups the user groups 3375 * @throws SystemException if a system exception occurred 3376 */ 3377 public static void removeUserGroups(long pk, 3378 java.util.List<com.liferay.portal.model.UserGroup> userGroups) 3379 throws com.liferay.portal.kernel.exception.SystemException { 3380 getPersistence().removeUserGroups(pk, userGroups); 3381 } 3382 3383 /** 3384 * 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. 3385 * 3386 * @param pk the primary key of the group 3387 * @param userGroupPKs the primary keys of the user groups to be associated with the group 3388 * @throws SystemException if a system exception occurred 3389 */ 3390 public static void setUserGroups(long pk, long[] userGroupPKs) 3391 throws com.liferay.portal.kernel.exception.SystemException { 3392 getPersistence().setUserGroups(pk, userGroupPKs); 3393 } 3394 3395 /** 3396 * 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. 3397 * 3398 * @param pk the primary key of the group 3399 * @param userGroups the user groups to be associated with the group 3400 * @throws SystemException if a system exception occurred 3401 */ 3402 public static void setUserGroups(long pk, 3403 java.util.List<com.liferay.portal.model.UserGroup> userGroups) 3404 throws com.liferay.portal.kernel.exception.SystemException { 3405 getPersistence().setUserGroups(pk, userGroups); 3406 } 3407 3408 /** 3409 * Returns all the users associated with the group. 3410 * 3411 * @param pk the primary key of the group 3412 * @return the users associated with the group 3413 * @throws SystemException if a system exception occurred 3414 */ 3415 public static java.util.List<com.liferay.portal.model.User> getUsers( 3416 long pk) throws com.liferay.portal.kernel.exception.SystemException { 3417 return getPersistence().getUsers(pk); 3418 } 3419 3420 /** 3421 * Returns a range of all the users associated with the group. 3422 * 3423 * <p> 3424 * 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. 3425 * </p> 3426 * 3427 * @param pk the primary key of the group 3428 * @param start the lower bound of the range of groups 3429 * @param end the upper bound of the range of groups (not inclusive) 3430 * @return the range of users associated with the group 3431 * @throws SystemException if a system exception occurred 3432 */ 3433 public static java.util.List<com.liferay.portal.model.User> getUsers( 3434 long pk, int start, int end) 3435 throws com.liferay.portal.kernel.exception.SystemException { 3436 return getPersistence().getUsers(pk, start, end); 3437 } 3438 3439 /** 3440 * Returns an ordered range of all the users associated with the group. 3441 * 3442 * <p> 3443 * 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. 3444 * </p> 3445 * 3446 * @param pk the primary key of the group 3447 * @param start the lower bound of the range of groups 3448 * @param end the upper bound of the range of groups (not inclusive) 3449 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3450 * @return the ordered range of users associated with the group 3451 * @throws SystemException if a system exception occurred 3452 */ 3453 public static java.util.List<com.liferay.portal.model.User> getUsers( 3454 long pk, int start, int end, 3455 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3456 throws com.liferay.portal.kernel.exception.SystemException { 3457 return getPersistence().getUsers(pk, start, end, orderByComparator); 3458 } 3459 3460 /** 3461 * Returns the number of users associated with the group. 3462 * 3463 * @param pk the primary key of the group 3464 * @return the number of users associated with the group 3465 * @throws SystemException if a system exception occurred 3466 */ 3467 public static int getUsersSize(long pk) 3468 throws com.liferay.portal.kernel.exception.SystemException { 3469 return getPersistence().getUsersSize(pk); 3470 } 3471 3472 /** 3473 * Returns <code>true</code> if the user is associated with the group. 3474 * 3475 * @param pk the primary key of the group 3476 * @param userPK the primary key of the user 3477 * @return <code>true</code> if the user is associated with the group; <code>false</code> otherwise 3478 * @throws SystemException if a system exception occurred 3479 */ 3480 public static boolean containsUser(long pk, long userPK) 3481 throws com.liferay.portal.kernel.exception.SystemException { 3482 return getPersistence().containsUser(pk, userPK); 3483 } 3484 3485 /** 3486 * Returns <code>true</code> if the group has any users associated with it. 3487 * 3488 * @param pk the primary key of the group to check for associations with users 3489 * @return <code>true</code> if the group has any users associated with it; <code>false</code> otherwise 3490 * @throws SystemException if a system exception occurred 3491 */ 3492 public static boolean containsUsers(long pk) 3493 throws com.liferay.portal.kernel.exception.SystemException { 3494 return getPersistence().containsUsers(pk); 3495 } 3496 3497 /** 3498 * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3499 * 3500 * @param pk the primary key of the group 3501 * @param userPK the primary key of the user 3502 * @throws SystemException if a system exception occurred 3503 */ 3504 public static void addUser(long pk, long userPK) 3505 throws com.liferay.portal.kernel.exception.SystemException { 3506 getPersistence().addUser(pk, userPK); 3507 } 3508 3509 /** 3510 * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3511 * 3512 * @param pk the primary key of the group 3513 * @param user the user 3514 * @throws SystemException if a system exception occurred 3515 */ 3516 public static void addUser(long pk, com.liferay.portal.model.User user) 3517 throws com.liferay.portal.kernel.exception.SystemException { 3518 getPersistence().addUser(pk, user); 3519 } 3520 3521 /** 3522 * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3523 * 3524 * @param pk the primary key of the group 3525 * @param userPKs the primary keys of the users 3526 * @throws SystemException if a system exception occurred 3527 */ 3528 public static void addUsers(long pk, long[] userPKs) 3529 throws com.liferay.portal.kernel.exception.SystemException { 3530 getPersistence().addUsers(pk, userPKs); 3531 } 3532 3533 /** 3534 * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3535 * 3536 * @param pk the primary key of the group 3537 * @param users the users 3538 * @throws SystemException if a system exception occurred 3539 */ 3540 public static void addUsers(long pk, 3541 java.util.List<com.liferay.portal.model.User> users) 3542 throws com.liferay.portal.kernel.exception.SystemException { 3543 getPersistence().addUsers(pk, users); 3544 } 3545 3546 /** 3547 * Clears all associations between the group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3548 * 3549 * @param pk the primary key of the group to clear the associated users from 3550 * @throws SystemException if a system exception occurred 3551 */ 3552 public static void clearUsers(long pk) 3553 throws com.liferay.portal.kernel.exception.SystemException { 3554 getPersistence().clearUsers(pk); 3555 } 3556 3557 /** 3558 * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3559 * 3560 * @param pk the primary key of the group 3561 * @param userPK the primary key of the user 3562 * @throws SystemException if a system exception occurred 3563 */ 3564 public static void removeUser(long pk, long userPK) 3565 throws com.liferay.portal.kernel.exception.SystemException { 3566 getPersistence().removeUser(pk, userPK); 3567 } 3568 3569 /** 3570 * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3571 * 3572 * @param pk the primary key of the group 3573 * @param user the user 3574 * @throws SystemException if a system exception occurred 3575 */ 3576 public static void removeUser(long pk, com.liferay.portal.model.User user) 3577 throws com.liferay.portal.kernel.exception.SystemException { 3578 getPersistence().removeUser(pk, user); 3579 } 3580 3581 /** 3582 * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3583 * 3584 * @param pk the primary key of the group 3585 * @param userPKs the primary keys of the users 3586 * @throws SystemException if a system exception occurred 3587 */ 3588 public static void removeUsers(long pk, long[] userPKs) 3589 throws com.liferay.portal.kernel.exception.SystemException { 3590 getPersistence().removeUsers(pk, userPKs); 3591 } 3592 3593 /** 3594 * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3595 * 3596 * @param pk the primary key of the group 3597 * @param users the users 3598 * @throws SystemException if a system exception occurred 3599 */ 3600 public static void removeUsers(long pk, 3601 java.util.List<com.liferay.portal.model.User> users) 3602 throws com.liferay.portal.kernel.exception.SystemException { 3603 getPersistence().removeUsers(pk, users); 3604 } 3605 3606 /** 3607 * 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. 3608 * 3609 * @param pk the primary key of the group 3610 * @param userPKs the primary keys of the users to be associated with the group 3611 * @throws SystemException if a system exception occurred 3612 */ 3613 public static void setUsers(long pk, long[] userPKs) 3614 throws com.liferay.portal.kernel.exception.SystemException { 3615 getPersistence().setUsers(pk, userPKs); 3616 } 3617 3618 /** 3619 * 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. 3620 * 3621 * @param pk the primary key of the group 3622 * @param users the users to be associated with the group 3623 * @throws SystemException if a system exception occurred 3624 */ 3625 public static void setUsers(long pk, 3626 java.util.List<com.liferay.portal.model.User> users) 3627 throws com.liferay.portal.kernel.exception.SystemException { 3628 getPersistence().setUsers(pk, users); 3629 } 3630 3631 public static GroupPersistence getPersistence() { 3632 if (_persistence == null) { 3633 _persistence = (GroupPersistence)PortalBeanLocatorUtil.locate(GroupPersistence.class.getName()); 3634 3635 ReferenceRegistry.registerReference(GroupUtil.class, "_persistence"); 3636 } 3637 3638 return _persistence; 3639 } 3640 3641 /** 3642 * @deprecated As of 6.2.0 3643 */ 3644 public void setPersistence(GroupPersistence persistence) { 3645 } 3646 3647 private static GroupPersistence _persistence; 3648 }