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