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