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