001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.Website; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the website service. This utility wraps {@link com.liferay.portal.service.persistence.impl.WebsitePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see WebsitePersistence 037 * @see com.liferay.portal.service.persistence.impl.WebsitePersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class WebsiteUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(Website website) { 059 getPersistence().clearCache(website); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<Website> findWithDynamicQuery(DynamicQuery dynamicQuery) { 073 return getPersistence().findWithDynamicQuery(dynamicQuery); 074 } 075 076 /** 077 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 078 */ 079 public static List<Website> findWithDynamicQuery( 080 DynamicQuery dynamicQuery, int start, int end) { 081 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 082 } 083 084 /** 085 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 086 */ 087 public static List<Website> findWithDynamicQuery( 088 DynamicQuery dynamicQuery, int start, int end, 089 OrderByComparator<Website> orderByComparator) { 090 return getPersistence() 091 .findWithDynamicQuery(dynamicQuery, start, end, 092 orderByComparator); 093 } 094 095 /** 096 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 097 */ 098 public static Website update(Website website) { 099 return getPersistence().update(website); 100 } 101 102 /** 103 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 104 */ 105 public static Website update(Website website, ServiceContext serviceContext) { 106 return getPersistence().update(website, serviceContext); 107 } 108 109 /** 110 * Returns all the websites where uuid = ?. 111 * 112 * @param uuid the uuid 113 * @return the matching websites 114 */ 115 public static List<Website> findByUuid(java.lang.String uuid) { 116 return getPersistence().findByUuid(uuid); 117 } 118 119 /** 120 * Returns a range of all the websites where uuid = ?. 121 * 122 * <p> 123 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 WebsiteModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 124 * </p> 125 * 126 * @param uuid the uuid 127 * @param start the lower bound of the range of websites 128 * @param end the upper bound of the range of websites (not inclusive) 129 * @return the range of matching websites 130 */ 131 public static List<Website> findByUuid(java.lang.String uuid, int start, 132 int end) { 133 return getPersistence().findByUuid(uuid, start, end); 134 } 135 136 /** 137 * Returns an ordered range of all the websites where uuid = ?. 138 * 139 * <p> 140 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 WebsiteModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 141 * </p> 142 * 143 * @param uuid the uuid 144 * @param start the lower bound of the range of websites 145 * @param end the upper bound of the range of websites (not inclusive) 146 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 147 * @return the ordered range of matching websites 148 */ 149 public static List<Website> findByUuid(java.lang.String uuid, int start, 150 int end, OrderByComparator<Website> orderByComparator) { 151 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 152 } 153 154 /** 155 * Returns the first website in the ordered set where uuid = ?. 156 * 157 * @param uuid the uuid 158 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 159 * @return the first matching website 160 * @throws NoSuchWebsiteException if a matching website could not be found 161 */ 162 public static Website findByUuid_First(java.lang.String uuid, 163 OrderByComparator<Website> orderByComparator) 164 throws com.liferay.portal.NoSuchWebsiteException { 165 return getPersistence().findByUuid_First(uuid, orderByComparator); 166 } 167 168 /** 169 * Returns the first website in the ordered set where uuid = ?. 170 * 171 * @param uuid the uuid 172 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 173 * @return the first matching website, or <code>null</code> if a matching website could not be found 174 */ 175 public static Website fetchByUuid_First(java.lang.String uuid, 176 OrderByComparator<Website> orderByComparator) { 177 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 178 } 179 180 /** 181 * Returns the last website in the ordered set where uuid = ?. 182 * 183 * @param uuid the uuid 184 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 185 * @return the last matching website 186 * @throws NoSuchWebsiteException if a matching website could not be found 187 */ 188 public static Website findByUuid_Last(java.lang.String uuid, 189 OrderByComparator<Website> orderByComparator) 190 throws com.liferay.portal.NoSuchWebsiteException { 191 return getPersistence().findByUuid_Last(uuid, orderByComparator); 192 } 193 194 /** 195 * Returns the last website in the ordered set where uuid = ?. 196 * 197 * @param uuid the uuid 198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 199 * @return the last matching website, or <code>null</code> if a matching website could not be found 200 */ 201 public static Website fetchByUuid_Last(java.lang.String uuid, 202 OrderByComparator<Website> orderByComparator) { 203 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 204 } 205 206 /** 207 * Returns the websites before and after the current website in the ordered set where uuid = ?. 208 * 209 * @param websiteId the primary key of the current website 210 * @param uuid the uuid 211 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 212 * @return the previous, current, and next website 213 * @throws NoSuchWebsiteException if a website with the primary key could not be found 214 */ 215 public static Website[] findByUuid_PrevAndNext(long websiteId, 216 java.lang.String uuid, OrderByComparator<Website> orderByComparator) 217 throws com.liferay.portal.NoSuchWebsiteException { 218 return getPersistence() 219 .findByUuid_PrevAndNext(websiteId, uuid, orderByComparator); 220 } 221 222 /** 223 * Removes all the websites where uuid = ? from the database. 224 * 225 * @param uuid the uuid 226 */ 227 public static void removeByUuid(java.lang.String uuid) { 228 getPersistence().removeByUuid(uuid); 229 } 230 231 /** 232 * Returns the number of websites where uuid = ?. 233 * 234 * @param uuid the uuid 235 * @return the number of matching websites 236 */ 237 public static int countByUuid(java.lang.String uuid) { 238 return getPersistence().countByUuid(uuid); 239 } 240 241 /** 242 * Returns all the websites where uuid = ? and companyId = ?. 243 * 244 * @param uuid the uuid 245 * @param companyId the company ID 246 * @return the matching websites 247 */ 248 public static List<Website> findByUuid_C(java.lang.String uuid, 249 long companyId) { 250 return getPersistence().findByUuid_C(uuid, companyId); 251 } 252 253 /** 254 * Returns a range of all the websites where uuid = ? and companyId = ?. 255 * 256 * <p> 257 * 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 WebsiteModelImpl}. 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. 258 * </p> 259 * 260 * @param uuid the uuid 261 * @param companyId the company ID 262 * @param start the lower bound of the range of websites 263 * @param end the upper bound of the range of websites (not inclusive) 264 * @return the range of matching websites 265 */ 266 public static List<Website> findByUuid_C(java.lang.String uuid, 267 long companyId, int start, int end) { 268 return getPersistence().findByUuid_C(uuid, companyId, start, end); 269 } 270 271 /** 272 * Returns an ordered range of all the websites where uuid = ? and companyId = ?. 273 * 274 * <p> 275 * 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 WebsiteModelImpl}. 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. 276 * </p> 277 * 278 * @param uuid the uuid 279 * @param companyId the company ID 280 * @param start the lower bound of the range of websites 281 * @param end the upper bound of the range of websites (not inclusive) 282 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 283 * @return the ordered range of matching websites 284 */ 285 public static List<Website> findByUuid_C(java.lang.String uuid, 286 long companyId, int start, int end, 287 OrderByComparator<Website> orderByComparator) { 288 return getPersistence() 289 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 290 } 291 292 /** 293 * Returns the first website in the ordered set where uuid = ? and companyId = ?. 294 * 295 * @param uuid the uuid 296 * @param companyId the company ID 297 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 298 * @return the first matching website 299 * @throws NoSuchWebsiteException if a matching website could not be found 300 */ 301 public static Website findByUuid_C_First(java.lang.String uuid, 302 long companyId, OrderByComparator<Website> orderByComparator) 303 throws com.liferay.portal.NoSuchWebsiteException { 304 return getPersistence() 305 .findByUuid_C_First(uuid, companyId, orderByComparator); 306 } 307 308 /** 309 * Returns the first website in the ordered set where uuid = ? and companyId = ?. 310 * 311 * @param uuid the uuid 312 * @param companyId the company ID 313 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 314 * @return the first matching website, or <code>null</code> if a matching website could not be found 315 */ 316 public static Website fetchByUuid_C_First(java.lang.String uuid, 317 long companyId, OrderByComparator<Website> orderByComparator) { 318 return getPersistence() 319 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 320 } 321 322 /** 323 * Returns the last website in the ordered set where uuid = ? and companyId = ?. 324 * 325 * @param uuid the uuid 326 * @param companyId the company ID 327 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 328 * @return the last matching website 329 * @throws NoSuchWebsiteException if a matching website could not be found 330 */ 331 public static Website findByUuid_C_Last(java.lang.String uuid, 332 long companyId, OrderByComparator<Website> orderByComparator) 333 throws com.liferay.portal.NoSuchWebsiteException { 334 return getPersistence() 335 .findByUuid_C_Last(uuid, companyId, orderByComparator); 336 } 337 338 /** 339 * Returns the last website in the ordered set where uuid = ? and companyId = ?. 340 * 341 * @param uuid the uuid 342 * @param companyId the company ID 343 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 344 * @return the last matching website, or <code>null</code> if a matching website could not be found 345 */ 346 public static Website fetchByUuid_C_Last(java.lang.String uuid, 347 long companyId, OrderByComparator<Website> orderByComparator) { 348 return getPersistence() 349 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 350 } 351 352 /** 353 * Returns the websites before and after the current website in the ordered set where uuid = ? and companyId = ?. 354 * 355 * @param websiteId the primary key of the current website 356 * @param uuid the uuid 357 * @param companyId the company ID 358 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 359 * @return the previous, current, and next website 360 * @throws NoSuchWebsiteException if a website with the primary key could not be found 361 */ 362 public static Website[] findByUuid_C_PrevAndNext(long websiteId, 363 java.lang.String uuid, long companyId, 364 OrderByComparator<Website> orderByComparator) 365 throws com.liferay.portal.NoSuchWebsiteException { 366 return getPersistence() 367 .findByUuid_C_PrevAndNext(websiteId, uuid, companyId, 368 orderByComparator); 369 } 370 371 /** 372 * Removes all the websites where uuid = ? and companyId = ? from the database. 373 * 374 * @param uuid the uuid 375 * @param companyId the company ID 376 */ 377 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 378 getPersistence().removeByUuid_C(uuid, companyId); 379 } 380 381 /** 382 * Returns the number of websites where uuid = ? and companyId = ?. 383 * 384 * @param uuid the uuid 385 * @param companyId the company ID 386 * @return the number of matching websites 387 */ 388 public static int countByUuid_C(java.lang.String uuid, long companyId) { 389 return getPersistence().countByUuid_C(uuid, companyId); 390 } 391 392 /** 393 * Returns all the websites where companyId = ?. 394 * 395 * @param companyId the company ID 396 * @return the matching websites 397 */ 398 public static List<Website> findByCompanyId(long companyId) { 399 return getPersistence().findByCompanyId(companyId); 400 } 401 402 /** 403 * Returns a range of all the websites where companyId = ?. 404 * 405 * <p> 406 * 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 WebsiteModelImpl}. 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. 407 * </p> 408 * 409 * @param companyId the company ID 410 * @param start the lower bound of the range of websites 411 * @param end the upper bound of the range of websites (not inclusive) 412 * @return the range of matching websites 413 */ 414 public static List<Website> findByCompanyId(long companyId, int start, 415 int end) { 416 return getPersistence().findByCompanyId(companyId, start, end); 417 } 418 419 /** 420 * Returns an ordered range of all the websites where companyId = ?. 421 * 422 * <p> 423 * 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 WebsiteModelImpl}. 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. 424 * </p> 425 * 426 * @param companyId the company ID 427 * @param start the lower bound of the range of websites 428 * @param end the upper bound of the range of websites (not inclusive) 429 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 430 * @return the ordered range of matching websites 431 */ 432 public static List<Website> findByCompanyId(long companyId, int start, 433 int end, OrderByComparator<Website> orderByComparator) { 434 return getPersistence() 435 .findByCompanyId(companyId, start, end, orderByComparator); 436 } 437 438 /** 439 * Returns the first website in the ordered set where companyId = ?. 440 * 441 * @param companyId the company ID 442 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 443 * @return the first matching website 444 * @throws NoSuchWebsiteException if a matching website could not be found 445 */ 446 public static Website findByCompanyId_First(long companyId, 447 OrderByComparator<Website> orderByComparator) 448 throws com.liferay.portal.NoSuchWebsiteException { 449 return getPersistence() 450 .findByCompanyId_First(companyId, orderByComparator); 451 } 452 453 /** 454 * Returns the first website in the ordered set where companyId = ?. 455 * 456 * @param companyId the company ID 457 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 458 * @return the first matching website, or <code>null</code> if a matching website could not be found 459 */ 460 public static Website fetchByCompanyId_First(long companyId, 461 OrderByComparator<Website> orderByComparator) { 462 return getPersistence() 463 .fetchByCompanyId_First(companyId, orderByComparator); 464 } 465 466 /** 467 * Returns the last website in the ordered set where companyId = ?. 468 * 469 * @param companyId the company ID 470 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 471 * @return the last matching website 472 * @throws NoSuchWebsiteException if a matching website could not be found 473 */ 474 public static Website findByCompanyId_Last(long companyId, 475 OrderByComparator<Website> orderByComparator) 476 throws com.liferay.portal.NoSuchWebsiteException { 477 return getPersistence() 478 .findByCompanyId_Last(companyId, orderByComparator); 479 } 480 481 /** 482 * Returns the last website in the ordered set where companyId = ?. 483 * 484 * @param companyId the company ID 485 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 486 * @return the last matching website, or <code>null</code> if a matching website could not be found 487 */ 488 public static Website fetchByCompanyId_Last(long companyId, 489 OrderByComparator<Website> orderByComparator) { 490 return getPersistence() 491 .fetchByCompanyId_Last(companyId, orderByComparator); 492 } 493 494 /** 495 * Returns the websites before and after the current website in the ordered set where companyId = ?. 496 * 497 * @param websiteId the primary key of the current website 498 * @param companyId the company ID 499 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 500 * @return the previous, current, and next website 501 * @throws NoSuchWebsiteException if a website with the primary key could not be found 502 */ 503 public static Website[] findByCompanyId_PrevAndNext(long websiteId, 504 long companyId, OrderByComparator<Website> orderByComparator) 505 throws com.liferay.portal.NoSuchWebsiteException { 506 return getPersistence() 507 .findByCompanyId_PrevAndNext(websiteId, companyId, 508 orderByComparator); 509 } 510 511 /** 512 * Removes all the websites where companyId = ? from the database. 513 * 514 * @param companyId the company ID 515 */ 516 public static void removeByCompanyId(long companyId) { 517 getPersistence().removeByCompanyId(companyId); 518 } 519 520 /** 521 * Returns the number of websites where companyId = ?. 522 * 523 * @param companyId the company ID 524 * @return the number of matching websites 525 */ 526 public static int countByCompanyId(long companyId) { 527 return getPersistence().countByCompanyId(companyId); 528 } 529 530 /** 531 * Returns all the websites where userId = ?. 532 * 533 * @param userId the user ID 534 * @return the matching websites 535 */ 536 public static List<Website> findByUserId(long userId) { 537 return getPersistence().findByUserId(userId); 538 } 539 540 /** 541 * Returns a range of all the websites where userId = ?. 542 * 543 * <p> 544 * 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 WebsiteModelImpl}. 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. 545 * </p> 546 * 547 * @param userId the user ID 548 * @param start the lower bound of the range of websites 549 * @param end the upper bound of the range of websites (not inclusive) 550 * @return the range of matching websites 551 */ 552 public static List<Website> findByUserId(long userId, int start, int end) { 553 return getPersistence().findByUserId(userId, start, end); 554 } 555 556 /** 557 * Returns an ordered range of all the websites where userId = ?. 558 * 559 * <p> 560 * 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 WebsiteModelImpl}. 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. 561 * </p> 562 * 563 * @param userId the user ID 564 * @param start the lower bound of the range of websites 565 * @param end the upper bound of the range of websites (not inclusive) 566 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 567 * @return the ordered range of matching websites 568 */ 569 public static List<Website> findByUserId(long userId, int start, int end, 570 OrderByComparator<Website> orderByComparator) { 571 return getPersistence() 572 .findByUserId(userId, start, end, orderByComparator); 573 } 574 575 /** 576 * Returns the first website in the ordered set where userId = ?. 577 * 578 * @param userId the user ID 579 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 580 * @return the first matching website 581 * @throws NoSuchWebsiteException if a matching website could not be found 582 */ 583 public static Website findByUserId_First(long userId, 584 OrderByComparator<Website> orderByComparator) 585 throws com.liferay.portal.NoSuchWebsiteException { 586 return getPersistence().findByUserId_First(userId, orderByComparator); 587 } 588 589 /** 590 * Returns the first website in the ordered set where userId = ?. 591 * 592 * @param userId the user ID 593 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 594 * @return the first matching website, or <code>null</code> if a matching website could not be found 595 */ 596 public static Website fetchByUserId_First(long userId, 597 OrderByComparator<Website> orderByComparator) { 598 return getPersistence().fetchByUserId_First(userId, orderByComparator); 599 } 600 601 /** 602 * Returns the last website in the ordered set where userId = ?. 603 * 604 * @param userId the user ID 605 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 606 * @return the last matching website 607 * @throws NoSuchWebsiteException if a matching website could not be found 608 */ 609 public static Website findByUserId_Last(long userId, 610 OrderByComparator<Website> orderByComparator) 611 throws com.liferay.portal.NoSuchWebsiteException { 612 return getPersistence().findByUserId_Last(userId, orderByComparator); 613 } 614 615 /** 616 * Returns the last website in the ordered set where userId = ?. 617 * 618 * @param userId the user ID 619 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 620 * @return the last matching website, or <code>null</code> if a matching website could not be found 621 */ 622 public static Website fetchByUserId_Last(long userId, 623 OrderByComparator<Website> orderByComparator) { 624 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 625 } 626 627 /** 628 * Returns the websites before and after the current website in the ordered set where userId = ?. 629 * 630 * @param websiteId the primary key of the current website 631 * @param userId the user ID 632 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 633 * @return the previous, current, and next website 634 * @throws NoSuchWebsiteException if a website with the primary key could not be found 635 */ 636 public static Website[] findByUserId_PrevAndNext(long websiteId, 637 long userId, OrderByComparator<Website> orderByComparator) 638 throws com.liferay.portal.NoSuchWebsiteException { 639 return getPersistence() 640 .findByUserId_PrevAndNext(websiteId, userId, 641 orderByComparator); 642 } 643 644 /** 645 * Removes all the websites where userId = ? from the database. 646 * 647 * @param userId the user ID 648 */ 649 public static void removeByUserId(long userId) { 650 getPersistence().removeByUserId(userId); 651 } 652 653 /** 654 * Returns the number of websites where userId = ?. 655 * 656 * @param userId the user ID 657 * @return the number of matching websites 658 */ 659 public static int countByUserId(long userId) { 660 return getPersistence().countByUserId(userId); 661 } 662 663 /** 664 * Returns all the websites where companyId = ? and classNameId = ?. 665 * 666 * @param companyId the company ID 667 * @param classNameId the class name ID 668 * @return the matching websites 669 */ 670 public static List<Website> findByC_C(long companyId, long classNameId) { 671 return getPersistence().findByC_C(companyId, classNameId); 672 } 673 674 /** 675 * Returns a range of all the websites where companyId = ? and classNameId = ?. 676 * 677 * <p> 678 * 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 WebsiteModelImpl}. 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. 679 * </p> 680 * 681 * @param companyId the company ID 682 * @param classNameId the class name ID 683 * @param start the lower bound of the range of websites 684 * @param end the upper bound of the range of websites (not inclusive) 685 * @return the range of matching websites 686 */ 687 public static List<Website> findByC_C(long companyId, long classNameId, 688 int start, int end) { 689 return getPersistence().findByC_C(companyId, classNameId, start, end); 690 } 691 692 /** 693 * Returns an ordered range of all the websites where companyId = ? and classNameId = ?. 694 * 695 * <p> 696 * 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 WebsiteModelImpl}. 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. 697 * </p> 698 * 699 * @param companyId the company ID 700 * @param classNameId the class name ID 701 * @param start the lower bound of the range of websites 702 * @param end the upper bound of the range of websites (not inclusive) 703 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 704 * @return the ordered range of matching websites 705 */ 706 public static List<Website> findByC_C(long companyId, long classNameId, 707 int start, int end, OrderByComparator<Website> orderByComparator) { 708 return getPersistence() 709 .findByC_C(companyId, classNameId, start, end, 710 orderByComparator); 711 } 712 713 /** 714 * Returns the first website in the ordered set where companyId = ? and classNameId = ?. 715 * 716 * @param companyId the company ID 717 * @param classNameId the class name ID 718 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 719 * @return the first matching website 720 * @throws NoSuchWebsiteException if a matching website could not be found 721 */ 722 public static Website findByC_C_First(long companyId, long classNameId, 723 OrderByComparator<Website> orderByComparator) 724 throws com.liferay.portal.NoSuchWebsiteException { 725 return getPersistence() 726 .findByC_C_First(companyId, classNameId, orderByComparator); 727 } 728 729 /** 730 * Returns the first website in the ordered set where companyId = ? and classNameId = ?. 731 * 732 * @param companyId the company ID 733 * @param classNameId the class name ID 734 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 735 * @return the first matching website, or <code>null</code> if a matching website could not be found 736 */ 737 public static Website fetchByC_C_First(long companyId, long classNameId, 738 OrderByComparator<Website> orderByComparator) { 739 return getPersistence() 740 .fetchByC_C_First(companyId, classNameId, orderByComparator); 741 } 742 743 /** 744 * Returns the last website in the ordered set where companyId = ? and classNameId = ?. 745 * 746 * @param companyId the company ID 747 * @param classNameId the class name ID 748 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 749 * @return the last matching website 750 * @throws NoSuchWebsiteException if a matching website could not be found 751 */ 752 public static Website findByC_C_Last(long companyId, long classNameId, 753 OrderByComparator<Website> orderByComparator) 754 throws com.liferay.portal.NoSuchWebsiteException { 755 return getPersistence() 756 .findByC_C_Last(companyId, classNameId, orderByComparator); 757 } 758 759 /** 760 * Returns the last website in the ordered set where companyId = ? and classNameId = ?. 761 * 762 * @param companyId the company ID 763 * @param classNameId the class name ID 764 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 765 * @return the last matching website, or <code>null</code> if a matching website could not be found 766 */ 767 public static Website fetchByC_C_Last(long companyId, long classNameId, 768 OrderByComparator<Website> orderByComparator) { 769 return getPersistence() 770 .fetchByC_C_Last(companyId, classNameId, orderByComparator); 771 } 772 773 /** 774 * Returns the websites before and after the current website in the ordered set where companyId = ? and classNameId = ?. 775 * 776 * @param websiteId the primary key of the current website 777 * @param companyId the company ID 778 * @param classNameId the class name ID 779 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 780 * @return the previous, current, and next website 781 * @throws NoSuchWebsiteException if a website with the primary key could not be found 782 */ 783 public static Website[] findByC_C_PrevAndNext(long websiteId, 784 long companyId, long classNameId, 785 OrderByComparator<Website> orderByComparator) 786 throws com.liferay.portal.NoSuchWebsiteException { 787 return getPersistence() 788 .findByC_C_PrevAndNext(websiteId, companyId, classNameId, 789 orderByComparator); 790 } 791 792 /** 793 * Removes all the websites where companyId = ? and classNameId = ? from the database. 794 * 795 * @param companyId the company ID 796 * @param classNameId the class name ID 797 */ 798 public static void removeByC_C(long companyId, long classNameId) { 799 getPersistence().removeByC_C(companyId, classNameId); 800 } 801 802 /** 803 * Returns the number of websites where companyId = ? and classNameId = ?. 804 * 805 * @param companyId the company ID 806 * @param classNameId the class name ID 807 * @return the number of matching websites 808 */ 809 public static int countByC_C(long companyId, long classNameId) { 810 return getPersistence().countByC_C(companyId, classNameId); 811 } 812 813 /** 814 * Returns all the websites where companyId = ? and classNameId = ? and classPK = ?. 815 * 816 * @param companyId the company ID 817 * @param classNameId the class name ID 818 * @param classPK the class p k 819 * @return the matching websites 820 */ 821 public static List<Website> findByC_C_C(long companyId, long classNameId, 822 long classPK) { 823 return getPersistence().findByC_C_C(companyId, classNameId, classPK); 824 } 825 826 /** 827 * Returns a range of all the websites where companyId = ? and classNameId = ? and classPK = ?. 828 * 829 * <p> 830 * 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 WebsiteModelImpl}. 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. 831 * </p> 832 * 833 * @param companyId the company ID 834 * @param classNameId the class name ID 835 * @param classPK the class p k 836 * @param start the lower bound of the range of websites 837 * @param end the upper bound of the range of websites (not inclusive) 838 * @return the range of matching websites 839 */ 840 public static List<Website> findByC_C_C(long companyId, long classNameId, 841 long classPK, int start, int end) { 842 return getPersistence() 843 .findByC_C_C(companyId, classNameId, classPK, start, end); 844 } 845 846 /** 847 * Returns an ordered range of all the websites where companyId = ? and classNameId = ? and classPK = ?. 848 * 849 * <p> 850 * 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 WebsiteModelImpl}. 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. 851 * </p> 852 * 853 * @param companyId the company ID 854 * @param classNameId the class name ID 855 * @param classPK the class p k 856 * @param start the lower bound of the range of websites 857 * @param end the upper bound of the range of websites (not inclusive) 858 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 859 * @return the ordered range of matching websites 860 */ 861 public static List<Website> findByC_C_C(long companyId, long classNameId, 862 long classPK, int start, int end, 863 OrderByComparator<Website> orderByComparator) { 864 return getPersistence() 865 .findByC_C_C(companyId, classNameId, classPK, start, end, 866 orderByComparator); 867 } 868 869 /** 870 * Returns the first website in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 871 * 872 * @param companyId the company ID 873 * @param classNameId the class name ID 874 * @param classPK the class p k 875 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 876 * @return the first matching website 877 * @throws NoSuchWebsiteException if a matching website could not be found 878 */ 879 public static Website findByC_C_C_First(long companyId, long classNameId, 880 long classPK, OrderByComparator<Website> orderByComparator) 881 throws com.liferay.portal.NoSuchWebsiteException { 882 return getPersistence() 883 .findByC_C_C_First(companyId, classNameId, classPK, 884 orderByComparator); 885 } 886 887 /** 888 * Returns the first website in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 889 * 890 * @param companyId the company ID 891 * @param classNameId the class name ID 892 * @param classPK the class p k 893 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 894 * @return the first matching website, or <code>null</code> if a matching website could not be found 895 */ 896 public static Website fetchByC_C_C_First(long companyId, long classNameId, 897 long classPK, OrderByComparator<Website> orderByComparator) { 898 return getPersistence() 899 .fetchByC_C_C_First(companyId, classNameId, classPK, 900 orderByComparator); 901 } 902 903 /** 904 * Returns the last website in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 905 * 906 * @param companyId the company ID 907 * @param classNameId the class name ID 908 * @param classPK the class p k 909 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 910 * @return the last matching website 911 * @throws NoSuchWebsiteException if a matching website could not be found 912 */ 913 public static Website findByC_C_C_Last(long companyId, long classNameId, 914 long classPK, OrderByComparator<Website> orderByComparator) 915 throws com.liferay.portal.NoSuchWebsiteException { 916 return getPersistence() 917 .findByC_C_C_Last(companyId, classNameId, classPK, 918 orderByComparator); 919 } 920 921 /** 922 * Returns the last website in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 923 * 924 * @param companyId the company ID 925 * @param classNameId the class name ID 926 * @param classPK the class p k 927 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 928 * @return the last matching website, or <code>null</code> if a matching website could not be found 929 */ 930 public static Website fetchByC_C_C_Last(long companyId, long classNameId, 931 long classPK, OrderByComparator<Website> orderByComparator) { 932 return getPersistence() 933 .fetchByC_C_C_Last(companyId, classNameId, classPK, 934 orderByComparator); 935 } 936 937 /** 938 * Returns the websites before and after the current website in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 939 * 940 * @param websiteId the primary key of the current website 941 * @param companyId the company ID 942 * @param classNameId the class name ID 943 * @param classPK the class p k 944 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 945 * @return the previous, current, and next website 946 * @throws NoSuchWebsiteException if a website with the primary key could not be found 947 */ 948 public static Website[] findByC_C_C_PrevAndNext(long websiteId, 949 long companyId, long classNameId, long classPK, 950 OrderByComparator<Website> orderByComparator) 951 throws com.liferay.portal.NoSuchWebsiteException { 952 return getPersistence() 953 .findByC_C_C_PrevAndNext(websiteId, companyId, classNameId, 954 classPK, orderByComparator); 955 } 956 957 /** 958 * Removes all the websites where companyId = ? and classNameId = ? and classPK = ? from the database. 959 * 960 * @param companyId the company ID 961 * @param classNameId the class name ID 962 * @param classPK the class p k 963 */ 964 public static void removeByC_C_C(long companyId, long classNameId, 965 long classPK) { 966 getPersistence().removeByC_C_C(companyId, classNameId, classPK); 967 } 968 969 /** 970 * Returns the number of websites where companyId = ? and classNameId = ? and classPK = ?. 971 * 972 * @param companyId the company ID 973 * @param classNameId the class name ID 974 * @param classPK the class p k 975 * @return the number of matching websites 976 */ 977 public static int countByC_C_C(long companyId, long classNameId, 978 long classPK) { 979 return getPersistence().countByC_C_C(companyId, classNameId, classPK); 980 } 981 982 /** 983 * Returns all the websites where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 984 * 985 * @param companyId the company ID 986 * @param classNameId the class name ID 987 * @param classPK the class p k 988 * @param primary the primary 989 * @return the matching websites 990 */ 991 public static List<Website> findByC_C_C_P(long companyId, long classNameId, 992 long classPK, boolean primary) { 993 return getPersistence() 994 .findByC_C_C_P(companyId, classNameId, classPK, primary); 995 } 996 997 /** 998 * Returns a range of all the websites where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 999 * 1000 * <p> 1001 * 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 WebsiteModelImpl}. 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. 1002 * </p> 1003 * 1004 * @param companyId the company ID 1005 * @param classNameId the class name ID 1006 * @param classPK the class p k 1007 * @param primary the primary 1008 * @param start the lower bound of the range of websites 1009 * @param end the upper bound of the range of websites (not inclusive) 1010 * @return the range of matching websites 1011 */ 1012 public static List<Website> findByC_C_C_P(long companyId, long classNameId, 1013 long classPK, boolean primary, int start, int end) { 1014 return getPersistence() 1015 .findByC_C_C_P(companyId, classNameId, classPK, primary, 1016 start, end); 1017 } 1018 1019 /** 1020 * Returns an ordered range of all the websites where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1021 * 1022 * <p> 1023 * 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 WebsiteModelImpl}. 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. 1024 * </p> 1025 * 1026 * @param companyId the company ID 1027 * @param classNameId the class name ID 1028 * @param classPK the class p k 1029 * @param primary the primary 1030 * @param start the lower bound of the range of websites 1031 * @param end the upper bound of the range of websites (not inclusive) 1032 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1033 * @return the ordered range of matching websites 1034 */ 1035 public static List<Website> findByC_C_C_P(long companyId, long classNameId, 1036 long classPK, boolean primary, int start, int end, 1037 OrderByComparator<Website> orderByComparator) { 1038 return getPersistence() 1039 .findByC_C_C_P(companyId, classNameId, classPK, primary, 1040 start, end, orderByComparator); 1041 } 1042 1043 /** 1044 * Returns the first website in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1045 * 1046 * @param companyId the company ID 1047 * @param classNameId the class name ID 1048 * @param classPK the class p k 1049 * @param primary the primary 1050 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1051 * @return the first matching website 1052 * @throws NoSuchWebsiteException if a matching website could not be found 1053 */ 1054 public static Website findByC_C_C_P_First(long companyId, long classNameId, 1055 long classPK, boolean primary, 1056 OrderByComparator<Website> orderByComparator) 1057 throws com.liferay.portal.NoSuchWebsiteException { 1058 return getPersistence() 1059 .findByC_C_C_P_First(companyId, classNameId, classPK, 1060 primary, orderByComparator); 1061 } 1062 1063 /** 1064 * Returns the first website in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1065 * 1066 * @param companyId the company ID 1067 * @param classNameId the class name ID 1068 * @param classPK the class p k 1069 * @param primary the primary 1070 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1071 * @return the first matching website, or <code>null</code> if a matching website could not be found 1072 */ 1073 public static Website fetchByC_C_C_P_First(long companyId, 1074 long classNameId, long classPK, boolean primary, 1075 OrderByComparator<Website> orderByComparator) { 1076 return getPersistence() 1077 .fetchByC_C_C_P_First(companyId, classNameId, classPK, 1078 primary, orderByComparator); 1079 } 1080 1081 /** 1082 * Returns the last website in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1083 * 1084 * @param companyId the company ID 1085 * @param classNameId the class name ID 1086 * @param classPK the class p k 1087 * @param primary the primary 1088 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1089 * @return the last matching website 1090 * @throws NoSuchWebsiteException if a matching website could not be found 1091 */ 1092 public static Website findByC_C_C_P_Last(long companyId, long classNameId, 1093 long classPK, boolean primary, 1094 OrderByComparator<Website> orderByComparator) 1095 throws com.liferay.portal.NoSuchWebsiteException { 1096 return getPersistence() 1097 .findByC_C_C_P_Last(companyId, classNameId, classPK, 1098 primary, orderByComparator); 1099 } 1100 1101 /** 1102 * Returns the last website in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1103 * 1104 * @param companyId the company ID 1105 * @param classNameId the class name ID 1106 * @param classPK the class p k 1107 * @param primary the primary 1108 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1109 * @return the last matching website, or <code>null</code> if a matching website could not be found 1110 */ 1111 public static Website fetchByC_C_C_P_Last(long companyId, long classNameId, 1112 long classPK, boolean primary, 1113 OrderByComparator<Website> orderByComparator) { 1114 return getPersistence() 1115 .fetchByC_C_C_P_Last(companyId, classNameId, classPK, 1116 primary, orderByComparator); 1117 } 1118 1119 /** 1120 * Returns the websites before and after the current website in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1121 * 1122 * @param websiteId the primary key of the current website 1123 * @param companyId the company ID 1124 * @param classNameId the class name ID 1125 * @param classPK the class p k 1126 * @param primary the primary 1127 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1128 * @return the previous, current, and next website 1129 * @throws NoSuchWebsiteException if a website with the primary key could not be found 1130 */ 1131 public static Website[] findByC_C_C_P_PrevAndNext(long websiteId, 1132 long companyId, long classNameId, long classPK, boolean primary, 1133 OrderByComparator<Website> orderByComparator) 1134 throws com.liferay.portal.NoSuchWebsiteException { 1135 return getPersistence() 1136 .findByC_C_C_P_PrevAndNext(websiteId, companyId, 1137 classNameId, classPK, primary, orderByComparator); 1138 } 1139 1140 /** 1141 * Removes all the websites where companyId = ? and classNameId = ? and classPK = ? and primary = ? from the database. 1142 * 1143 * @param companyId the company ID 1144 * @param classNameId the class name ID 1145 * @param classPK the class p k 1146 * @param primary the primary 1147 */ 1148 public static void removeByC_C_C_P(long companyId, long classNameId, 1149 long classPK, boolean primary) { 1150 getPersistence() 1151 .removeByC_C_C_P(companyId, classNameId, classPK, primary); 1152 } 1153 1154 /** 1155 * Returns the number of websites where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1156 * 1157 * @param companyId the company ID 1158 * @param classNameId the class name ID 1159 * @param classPK the class p k 1160 * @param primary the primary 1161 * @return the number of matching websites 1162 */ 1163 public static int countByC_C_C_P(long companyId, long classNameId, 1164 long classPK, boolean primary) { 1165 return getPersistence() 1166 .countByC_C_C_P(companyId, classNameId, classPK, primary); 1167 } 1168 1169 /** 1170 * Caches the website in the entity cache if it is enabled. 1171 * 1172 * @param website the website 1173 */ 1174 public static void cacheResult(Website website) { 1175 getPersistence().cacheResult(website); 1176 } 1177 1178 /** 1179 * Caches the websites in the entity cache if it is enabled. 1180 * 1181 * @param websites the websites 1182 */ 1183 public static void cacheResult(List<Website> websites) { 1184 getPersistence().cacheResult(websites); 1185 } 1186 1187 /** 1188 * Creates a new website with the primary key. Does not add the website to the database. 1189 * 1190 * @param websiteId the primary key for the new website 1191 * @return the new website 1192 */ 1193 public static Website create(long websiteId) { 1194 return getPersistence().create(websiteId); 1195 } 1196 1197 /** 1198 * Removes the website with the primary key from the database. Also notifies the appropriate model listeners. 1199 * 1200 * @param websiteId the primary key of the website 1201 * @return the website that was removed 1202 * @throws NoSuchWebsiteException if a website with the primary key could not be found 1203 */ 1204 public static Website remove(long websiteId) 1205 throws com.liferay.portal.NoSuchWebsiteException { 1206 return getPersistence().remove(websiteId); 1207 } 1208 1209 public static Website updateImpl(Website website) { 1210 return getPersistence().updateImpl(website); 1211 } 1212 1213 /** 1214 * Returns the website with the primary key or throws a {@link NoSuchWebsiteException} if it could not be found. 1215 * 1216 * @param websiteId the primary key of the website 1217 * @return the website 1218 * @throws NoSuchWebsiteException if a website with the primary key could not be found 1219 */ 1220 public static Website findByPrimaryKey(long websiteId) 1221 throws com.liferay.portal.NoSuchWebsiteException { 1222 return getPersistence().findByPrimaryKey(websiteId); 1223 } 1224 1225 /** 1226 * Returns the website with the primary key or returns <code>null</code> if it could not be found. 1227 * 1228 * @param websiteId the primary key of the website 1229 * @return the website, or <code>null</code> if a website with the primary key could not be found 1230 */ 1231 public static Website fetchByPrimaryKey(long websiteId) { 1232 return getPersistence().fetchByPrimaryKey(websiteId); 1233 } 1234 1235 public static java.util.Map<java.io.Serializable, Website> fetchByPrimaryKeys( 1236 java.util.Set<java.io.Serializable> primaryKeys) { 1237 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1238 } 1239 1240 /** 1241 * Returns all the websites. 1242 * 1243 * @return the websites 1244 */ 1245 public static List<Website> findAll() { 1246 return getPersistence().findAll(); 1247 } 1248 1249 /** 1250 * Returns a range of all the websites. 1251 * 1252 * <p> 1253 * 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 WebsiteModelImpl}. 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. 1254 * </p> 1255 * 1256 * @param start the lower bound of the range of websites 1257 * @param end the upper bound of the range of websites (not inclusive) 1258 * @return the range of websites 1259 */ 1260 public static List<Website> findAll(int start, int end) { 1261 return getPersistence().findAll(start, end); 1262 } 1263 1264 /** 1265 * Returns an ordered range of all the websites. 1266 * 1267 * <p> 1268 * 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 WebsiteModelImpl}. 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. 1269 * </p> 1270 * 1271 * @param start the lower bound of the range of websites 1272 * @param end the upper bound of the range of websites (not inclusive) 1273 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1274 * @return the ordered range of websites 1275 */ 1276 public static List<Website> findAll(int start, int end, 1277 OrderByComparator<Website> orderByComparator) { 1278 return getPersistence().findAll(start, end, orderByComparator); 1279 } 1280 1281 /** 1282 * Removes all the websites from the database. 1283 */ 1284 public static void removeAll() { 1285 getPersistence().removeAll(); 1286 } 1287 1288 /** 1289 * Returns the number of websites. 1290 * 1291 * @return the number of websites 1292 */ 1293 public static int countAll() { 1294 return getPersistence().countAll(); 1295 } 1296 1297 public static WebsitePersistence getPersistence() { 1298 if (_persistence == null) { 1299 _persistence = (WebsitePersistence)PortalBeanLocatorUtil.locate(WebsitePersistence.class.getName()); 1300 1301 ReferenceRegistry.registerReference(WebsiteUtil.class, 1302 "_persistence"); 1303 } 1304 1305 return _persistence; 1306 } 1307 1308 /** 1309 * @deprecated As of 6.2.0 1310 */ 1311 @Deprecated 1312 public void setPersistence(WebsitePersistence persistence) { 1313 } 1314 1315 private static WebsitePersistence _persistence; 1316 }