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