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