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 an ordered range of all the websites where uuid = ?. 156 * 157 * <p> 158 * 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. 159 * </p> 160 * 161 * @param uuid the uuid 162 * @param start the lower bound of the range of websites 163 * @param end the upper bound of the range of websites (not inclusive) 164 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 165 * @param retrieveFromCache whether to retrieve from the finder cache 166 * @return the ordered range of matching websites 167 */ 168 public static List<Website> findByUuid(java.lang.String uuid, int start, 169 int end, OrderByComparator<Website> orderByComparator, 170 boolean retrieveFromCache) { 171 return getPersistence() 172 .findByUuid(uuid, start, end, orderByComparator, 173 retrieveFromCache); 174 } 175 176 /** 177 * Returns the first website in the ordered set where uuid = ?. 178 * 179 * @param uuid the uuid 180 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 181 * @return the first matching website 182 * @throws NoSuchWebsiteException if a matching website could not be found 183 */ 184 public static Website findByUuid_First(java.lang.String uuid, 185 OrderByComparator<Website> orderByComparator) 186 throws com.liferay.portal.exception.NoSuchWebsiteException { 187 return getPersistence().findByUuid_First(uuid, orderByComparator); 188 } 189 190 /** 191 * Returns the first website in the ordered set where uuid = ?. 192 * 193 * @param uuid the uuid 194 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 195 * @return the first matching website, or <code>null</code> if a matching website could not be found 196 */ 197 public static Website fetchByUuid_First(java.lang.String uuid, 198 OrderByComparator<Website> orderByComparator) { 199 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 200 } 201 202 /** 203 * Returns the last website in the ordered set where uuid = ?. 204 * 205 * @param uuid the uuid 206 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 207 * @return the last matching website 208 * @throws NoSuchWebsiteException if a matching website could not be found 209 */ 210 public static Website findByUuid_Last(java.lang.String uuid, 211 OrderByComparator<Website> orderByComparator) 212 throws com.liferay.portal.exception.NoSuchWebsiteException { 213 return getPersistence().findByUuid_Last(uuid, orderByComparator); 214 } 215 216 /** 217 * Returns the last website in the ordered set where uuid = ?. 218 * 219 * @param uuid the uuid 220 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 221 * @return the last matching website, or <code>null</code> if a matching website could not be found 222 */ 223 public static Website fetchByUuid_Last(java.lang.String uuid, 224 OrderByComparator<Website> orderByComparator) { 225 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 226 } 227 228 /** 229 * Returns the websites before and after the current website in the ordered set where uuid = ?. 230 * 231 * @param websiteId the primary key of the current website 232 * @param uuid the uuid 233 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 234 * @return the previous, current, and next website 235 * @throws NoSuchWebsiteException if a website with the primary key could not be found 236 */ 237 public static Website[] findByUuid_PrevAndNext(long websiteId, 238 java.lang.String uuid, OrderByComparator<Website> orderByComparator) 239 throws com.liferay.portal.exception.NoSuchWebsiteException { 240 return getPersistence() 241 .findByUuid_PrevAndNext(websiteId, uuid, orderByComparator); 242 } 243 244 /** 245 * Removes all the websites where uuid = ? from the database. 246 * 247 * @param uuid the uuid 248 */ 249 public static void removeByUuid(java.lang.String uuid) { 250 getPersistence().removeByUuid(uuid); 251 } 252 253 /** 254 * Returns the number of websites where uuid = ?. 255 * 256 * @param uuid the uuid 257 * @return the number of matching websites 258 */ 259 public static int countByUuid(java.lang.String uuid) { 260 return getPersistence().countByUuid(uuid); 261 } 262 263 /** 264 * Returns all the websites where uuid = ? and companyId = ?. 265 * 266 * @param uuid the uuid 267 * @param companyId the company ID 268 * @return the matching websites 269 */ 270 public static List<Website> findByUuid_C(java.lang.String uuid, 271 long companyId) { 272 return getPersistence().findByUuid_C(uuid, companyId); 273 } 274 275 /** 276 * Returns a range of all the websites where uuid = ? and companyId = ?. 277 * 278 * <p> 279 * 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. 280 * </p> 281 * 282 * @param uuid the uuid 283 * @param companyId the company ID 284 * @param start the lower bound of the range of websites 285 * @param end the upper bound of the range of websites (not inclusive) 286 * @return the range of matching websites 287 */ 288 public static List<Website> findByUuid_C(java.lang.String uuid, 289 long companyId, int start, int end) { 290 return getPersistence().findByUuid_C(uuid, companyId, start, end); 291 } 292 293 /** 294 * Returns an ordered range of all the websites where uuid = ? and companyId = ?. 295 * 296 * <p> 297 * 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. 298 * </p> 299 * 300 * @param uuid the uuid 301 * @param companyId the company ID 302 * @param start the lower bound of the range of websites 303 * @param end the upper bound of the range of websites (not inclusive) 304 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 305 * @return the ordered range of matching websites 306 */ 307 public static List<Website> findByUuid_C(java.lang.String uuid, 308 long companyId, int start, int end, 309 OrderByComparator<Website> orderByComparator) { 310 return getPersistence() 311 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 312 } 313 314 /** 315 * Returns an ordered range of all the websites where uuid = ? and companyId = ?. 316 * 317 * <p> 318 * 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. 319 * </p> 320 * 321 * @param uuid the uuid 322 * @param companyId the company ID 323 * @param start the lower bound of the range of websites 324 * @param end the upper bound of the range of websites (not inclusive) 325 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 326 * @param retrieveFromCache whether to retrieve from the finder cache 327 * @return the ordered range of matching websites 328 */ 329 public static List<Website> findByUuid_C(java.lang.String uuid, 330 long companyId, int start, int end, 331 OrderByComparator<Website> orderByComparator, boolean retrieveFromCache) { 332 return getPersistence() 333 .findByUuid_C(uuid, companyId, start, end, 334 orderByComparator, retrieveFromCache); 335 } 336 337 /** 338 * Returns the first website in the ordered set where uuid = ? and companyId = ?. 339 * 340 * @param uuid the uuid 341 * @param companyId the company ID 342 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 343 * @return the first matching website 344 * @throws NoSuchWebsiteException if a matching website could not be found 345 */ 346 public static Website findByUuid_C_First(java.lang.String uuid, 347 long companyId, OrderByComparator<Website> orderByComparator) 348 throws com.liferay.portal.exception.NoSuchWebsiteException { 349 return getPersistence() 350 .findByUuid_C_First(uuid, companyId, orderByComparator); 351 } 352 353 /** 354 * Returns the first website in the ordered set where uuid = ? and companyId = ?. 355 * 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 first matching website, or <code>null</code> if a matching website could not be found 360 */ 361 public static Website fetchByUuid_C_First(java.lang.String uuid, 362 long companyId, OrderByComparator<Website> orderByComparator) { 363 return getPersistence() 364 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 365 } 366 367 /** 368 * Returns the last website in the ordered set where uuid = ? and companyId = ?. 369 * 370 * @param uuid the uuid 371 * @param companyId the company ID 372 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 373 * @return the last matching website 374 * @throws NoSuchWebsiteException if a matching website could not be found 375 */ 376 public static Website findByUuid_C_Last(java.lang.String uuid, 377 long companyId, OrderByComparator<Website> orderByComparator) 378 throws com.liferay.portal.exception.NoSuchWebsiteException { 379 return getPersistence() 380 .findByUuid_C_Last(uuid, companyId, orderByComparator); 381 } 382 383 /** 384 * Returns the last website in the ordered set where uuid = ? and companyId = ?. 385 * 386 * @param uuid the uuid 387 * @param companyId the company ID 388 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 389 * @return the last matching website, or <code>null</code> if a matching website could not be found 390 */ 391 public static Website fetchByUuid_C_Last(java.lang.String uuid, 392 long companyId, OrderByComparator<Website> orderByComparator) { 393 return getPersistence() 394 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 395 } 396 397 /** 398 * Returns the websites before and after the current website in the ordered set where uuid = ? and companyId = ?. 399 * 400 * @param websiteId the primary key of the current website 401 * @param uuid the uuid 402 * @param companyId the company ID 403 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 404 * @return the previous, current, and next website 405 * @throws NoSuchWebsiteException if a website with the primary key could not be found 406 */ 407 public static Website[] findByUuid_C_PrevAndNext(long websiteId, 408 java.lang.String uuid, long companyId, 409 OrderByComparator<Website> orderByComparator) 410 throws com.liferay.portal.exception.NoSuchWebsiteException { 411 return getPersistence() 412 .findByUuid_C_PrevAndNext(websiteId, uuid, companyId, 413 orderByComparator); 414 } 415 416 /** 417 * Removes all the websites where uuid = ? and companyId = ? from the database. 418 * 419 * @param uuid the uuid 420 * @param companyId the company ID 421 */ 422 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 423 getPersistence().removeByUuid_C(uuid, companyId); 424 } 425 426 /** 427 * Returns the number of websites where uuid = ? and companyId = ?. 428 * 429 * @param uuid the uuid 430 * @param companyId the company ID 431 * @return the number of matching websites 432 */ 433 public static int countByUuid_C(java.lang.String uuid, long companyId) { 434 return getPersistence().countByUuid_C(uuid, companyId); 435 } 436 437 /** 438 * Returns all the websites where companyId = ?. 439 * 440 * @param companyId the company ID 441 * @return the matching websites 442 */ 443 public static List<Website> findByCompanyId(long companyId) { 444 return getPersistence().findByCompanyId(companyId); 445 } 446 447 /** 448 * Returns a range of all the websites where companyId = ?. 449 * 450 * <p> 451 * 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. 452 * </p> 453 * 454 * @param companyId the company ID 455 * @param start the lower bound of the range of websites 456 * @param end the upper bound of the range of websites (not inclusive) 457 * @return the range of matching websites 458 */ 459 public static List<Website> findByCompanyId(long companyId, int start, 460 int end) { 461 return getPersistence().findByCompanyId(companyId, start, end); 462 } 463 464 /** 465 * Returns an ordered range of all the websites where companyId = ?. 466 * 467 * <p> 468 * 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. 469 * </p> 470 * 471 * @param companyId the company ID 472 * @param start the lower bound of the range of websites 473 * @param end the upper bound of the range of websites (not inclusive) 474 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 475 * @return the ordered range of matching websites 476 */ 477 public static List<Website> findByCompanyId(long companyId, int start, 478 int end, OrderByComparator<Website> orderByComparator) { 479 return getPersistence() 480 .findByCompanyId(companyId, start, end, orderByComparator); 481 } 482 483 /** 484 * Returns an ordered range of all the websites where companyId = ?. 485 * 486 * <p> 487 * 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. 488 * </p> 489 * 490 * @param companyId the company ID 491 * @param start the lower bound of the range of websites 492 * @param end the upper bound of the range of websites (not inclusive) 493 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 494 * @param retrieveFromCache whether to retrieve from the finder cache 495 * @return the ordered range of matching websites 496 */ 497 public static List<Website> findByCompanyId(long companyId, int start, 498 int end, OrderByComparator<Website> orderByComparator, 499 boolean retrieveFromCache) { 500 return getPersistence() 501 .findByCompanyId(companyId, start, end, orderByComparator, 502 retrieveFromCache); 503 } 504 505 /** 506 * Returns the first website in the ordered set where companyId = ?. 507 * 508 * @param companyId the company ID 509 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 510 * @return the first matching website 511 * @throws NoSuchWebsiteException if a matching website could not be found 512 */ 513 public static Website findByCompanyId_First(long companyId, 514 OrderByComparator<Website> orderByComparator) 515 throws com.liferay.portal.exception.NoSuchWebsiteException { 516 return getPersistence() 517 .findByCompanyId_First(companyId, orderByComparator); 518 } 519 520 /** 521 * Returns the first website in the ordered set where companyId = ?. 522 * 523 * @param companyId the company ID 524 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 525 * @return the first matching website, or <code>null</code> if a matching website could not be found 526 */ 527 public static Website fetchByCompanyId_First(long companyId, 528 OrderByComparator<Website> orderByComparator) { 529 return getPersistence() 530 .fetchByCompanyId_First(companyId, orderByComparator); 531 } 532 533 /** 534 * Returns the last website in the ordered set where companyId = ?. 535 * 536 * @param companyId the company ID 537 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 538 * @return the last matching website 539 * @throws NoSuchWebsiteException if a matching website could not be found 540 */ 541 public static Website findByCompanyId_Last(long companyId, 542 OrderByComparator<Website> orderByComparator) 543 throws com.liferay.portal.exception.NoSuchWebsiteException { 544 return getPersistence() 545 .findByCompanyId_Last(companyId, orderByComparator); 546 } 547 548 /** 549 * Returns the last website in the ordered set where companyId = ?. 550 * 551 * @param companyId the company ID 552 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 553 * @return the last matching website, or <code>null</code> if a matching website could not be found 554 */ 555 public static Website fetchByCompanyId_Last(long companyId, 556 OrderByComparator<Website> orderByComparator) { 557 return getPersistence() 558 .fetchByCompanyId_Last(companyId, orderByComparator); 559 } 560 561 /** 562 * Returns the websites before and after the current website in the ordered set where companyId = ?. 563 * 564 * @param websiteId the primary key of the current website 565 * @param companyId the company ID 566 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 567 * @return the previous, current, and next website 568 * @throws NoSuchWebsiteException if a website with the primary key could not be found 569 */ 570 public static Website[] findByCompanyId_PrevAndNext(long websiteId, 571 long companyId, OrderByComparator<Website> orderByComparator) 572 throws com.liferay.portal.exception.NoSuchWebsiteException { 573 return getPersistence() 574 .findByCompanyId_PrevAndNext(websiteId, companyId, 575 orderByComparator); 576 } 577 578 /** 579 * Removes all the websites where companyId = ? from the database. 580 * 581 * @param companyId the company ID 582 */ 583 public static void removeByCompanyId(long companyId) { 584 getPersistence().removeByCompanyId(companyId); 585 } 586 587 /** 588 * Returns the number of websites where companyId = ?. 589 * 590 * @param companyId the company ID 591 * @return the number of matching websites 592 */ 593 public static int countByCompanyId(long companyId) { 594 return getPersistence().countByCompanyId(companyId); 595 } 596 597 /** 598 * Returns all the websites where userId = ?. 599 * 600 * @param userId the user ID 601 * @return the matching websites 602 */ 603 public static List<Website> findByUserId(long userId) { 604 return getPersistence().findByUserId(userId); 605 } 606 607 /** 608 * Returns a range of all the websites where userId = ?. 609 * 610 * <p> 611 * 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. 612 * </p> 613 * 614 * @param userId the user ID 615 * @param start the lower bound of the range of websites 616 * @param end the upper bound of the range of websites (not inclusive) 617 * @return the range of matching websites 618 */ 619 public static List<Website> findByUserId(long userId, int start, int end) { 620 return getPersistence().findByUserId(userId, start, end); 621 } 622 623 /** 624 * Returns an ordered range of all the websites where userId = ?. 625 * 626 * <p> 627 * 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. 628 * </p> 629 * 630 * @param userId the user ID 631 * @param start the lower bound of the range of websites 632 * @param end the upper bound of the range of websites (not inclusive) 633 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 634 * @return the ordered range of matching websites 635 */ 636 public static List<Website> findByUserId(long userId, int start, int end, 637 OrderByComparator<Website> orderByComparator) { 638 return getPersistence() 639 .findByUserId(userId, start, end, orderByComparator); 640 } 641 642 /** 643 * Returns an ordered range of all the websites where userId = ?. 644 * 645 * <p> 646 * 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. 647 * </p> 648 * 649 * @param userId the user ID 650 * @param start the lower bound of the range of websites 651 * @param end the upper bound of the range of websites (not inclusive) 652 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 653 * @param retrieveFromCache whether to retrieve from the finder cache 654 * @return the ordered range of matching websites 655 */ 656 public static List<Website> findByUserId(long userId, int start, int end, 657 OrderByComparator<Website> orderByComparator, boolean retrieveFromCache) { 658 return getPersistence() 659 .findByUserId(userId, start, end, orderByComparator, 660 retrieveFromCache); 661 } 662 663 /** 664 * Returns the first website in the ordered set where userId = ?. 665 * 666 * @param userId the user ID 667 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 668 * @return the first matching website 669 * @throws NoSuchWebsiteException if a matching website could not be found 670 */ 671 public static Website findByUserId_First(long userId, 672 OrderByComparator<Website> orderByComparator) 673 throws com.liferay.portal.exception.NoSuchWebsiteException { 674 return getPersistence().findByUserId_First(userId, orderByComparator); 675 } 676 677 /** 678 * Returns the first website in the ordered set where userId = ?. 679 * 680 * @param userId the user ID 681 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 682 * @return the first matching website, or <code>null</code> if a matching website could not be found 683 */ 684 public static Website fetchByUserId_First(long userId, 685 OrderByComparator<Website> orderByComparator) { 686 return getPersistence().fetchByUserId_First(userId, orderByComparator); 687 } 688 689 /** 690 * Returns the last website in the ordered set where userId = ?. 691 * 692 * @param userId the user ID 693 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 694 * @return the last matching website 695 * @throws NoSuchWebsiteException if a matching website could not be found 696 */ 697 public static Website findByUserId_Last(long userId, 698 OrderByComparator<Website> orderByComparator) 699 throws com.liferay.portal.exception.NoSuchWebsiteException { 700 return getPersistence().findByUserId_Last(userId, orderByComparator); 701 } 702 703 /** 704 * Returns the last website in the ordered set where userId = ?. 705 * 706 * @param userId the user ID 707 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 708 * @return the last matching website, or <code>null</code> if a matching website could not be found 709 */ 710 public static Website fetchByUserId_Last(long userId, 711 OrderByComparator<Website> orderByComparator) { 712 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 713 } 714 715 /** 716 * Returns the websites before and after the current website in the ordered set where userId = ?. 717 * 718 * @param websiteId the primary key of the current website 719 * @param userId the user ID 720 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 721 * @return the previous, current, and next website 722 * @throws NoSuchWebsiteException if a website with the primary key could not be found 723 */ 724 public static Website[] findByUserId_PrevAndNext(long websiteId, 725 long userId, OrderByComparator<Website> orderByComparator) 726 throws com.liferay.portal.exception.NoSuchWebsiteException { 727 return getPersistence() 728 .findByUserId_PrevAndNext(websiteId, userId, 729 orderByComparator); 730 } 731 732 /** 733 * Removes all the websites where userId = ? from the database. 734 * 735 * @param userId the user ID 736 */ 737 public static void removeByUserId(long userId) { 738 getPersistence().removeByUserId(userId); 739 } 740 741 /** 742 * Returns the number of websites where userId = ?. 743 * 744 * @param userId the user ID 745 * @return the number of matching websites 746 */ 747 public static int countByUserId(long userId) { 748 return getPersistence().countByUserId(userId); 749 } 750 751 /** 752 * Returns all the websites where companyId = ? and classNameId = ?. 753 * 754 * @param companyId the company ID 755 * @param classNameId the class name ID 756 * @return the matching websites 757 */ 758 public static List<Website> findByC_C(long companyId, long classNameId) { 759 return getPersistence().findByC_C(companyId, classNameId); 760 } 761 762 /** 763 * Returns a range of all the websites where companyId = ? and classNameId = ?. 764 * 765 * <p> 766 * 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. 767 * </p> 768 * 769 * @param companyId the company ID 770 * @param classNameId the class name ID 771 * @param start the lower bound of the range of websites 772 * @param end the upper bound of the range of websites (not inclusive) 773 * @return the range of matching websites 774 */ 775 public static List<Website> findByC_C(long companyId, long classNameId, 776 int start, int end) { 777 return getPersistence().findByC_C(companyId, classNameId, start, end); 778 } 779 780 /** 781 * Returns an ordered range of all the websites where companyId = ? and classNameId = ?. 782 * 783 * <p> 784 * 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. 785 * </p> 786 * 787 * @param companyId the company ID 788 * @param classNameId the class name ID 789 * @param start the lower bound of the range of websites 790 * @param end the upper bound of the range of websites (not inclusive) 791 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 792 * @return the ordered range of matching websites 793 */ 794 public static List<Website> findByC_C(long companyId, long classNameId, 795 int start, int end, OrderByComparator<Website> orderByComparator) { 796 return getPersistence() 797 .findByC_C(companyId, classNameId, start, end, 798 orderByComparator); 799 } 800 801 /** 802 * Returns an ordered range of all the websites where companyId = ? and classNameId = ?. 803 * 804 * <p> 805 * 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. 806 * </p> 807 * 808 * @param companyId the company ID 809 * @param classNameId the class name ID 810 * @param start the lower bound of the range of websites 811 * @param end the upper bound of the range of websites (not inclusive) 812 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 813 * @param retrieveFromCache whether to retrieve from the finder cache 814 * @return the ordered range of matching websites 815 */ 816 public static List<Website> findByC_C(long companyId, long classNameId, 817 int start, int end, OrderByComparator<Website> orderByComparator, 818 boolean retrieveFromCache) { 819 return getPersistence() 820 .findByC_C(companyId, classNameId, start, end, 821 orderByComparator, retrieveFromCache); 822 } 823 824 /** 825 * Returns the first website in the ordered set where companyId = ? and classNameId = ?. 826 * 827 * @param companyId the company ID 828 * @param classNameId the class name ID 829 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 830 * @return the first matching website 831 * @throws NoSuchWebsiteException if a matching website could not be found 832 */ 833 public static Website findByC_C_First(long companyId, long classNameId, 834 OrderByComparator<Website> orderByComparator) 835 throws com.liferay.portal.exception.NoSuchWebsiteException { 836 return getPersistence() 837 .findByC_C_First(companyId, classNameId, orderByComparator); 838 } 839 840 /** 841 * Returns the first website in the ordered set where companyId = ? and classNameId = ?. 842 * 843 * @param companyId the company ID 844 * @param classNameId the class name ID 845 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 846 * @return the first matching website, or <code>null</code> if a matching website could not be found 847 */ 848 public static Website fetchByC_C_First(long companyId, long classNameId, 849 OrderByComparator<Website> orderByComparator) { 850 return getPersistence() 851 .fetchByC_C_First(companyId, classNameId, orderByComparator); 852 } 853 854 /** 855 * Returns the last website in the ordered set where companyId = ? and classNameId = ?. 856 * 857 * @param companyId the company ID 858 * @param classNameId the class name ID 859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 860 * @return the last matching website 861 * @throws NoSuchWebsiteException if a matching website could not be found 862 */ 863 public static Website findByC_C_Last(long companyId, long classNameId, 864 OrderByComparator<Website> orderByComparator) 865 throws com.liferay.portal.exception.NoSuchWebsiteException { 866 return getPersistence() 867 .findByC_C_Last(companyId, classNameId, orderByComparator); 868 } 869 870 /** 871 * Returns the last website in the ordered set where companyId = ? and classNameId = ?. 872 * 873 * @param companyId the company ID 874 * @param classNameId the class name ID 875 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 876 * @return the last matching website, or <code>null</code> if a matching website could not be found 877 */ 878 public static Website fetchByC_C_Last(long companyId, long classNameId, 879 OrderByComparator<Website> orderByComparator) { 880 return getPersistence() 881 .fetchByC_C_Last(companyId, classNameId, orderByComparator); 882 } 883 884 /** 885 * Returns the websites before and after the current website in the ordered set where companyId = ? and classNameId = ?. 886 * 887 * @param websiteId the primary key of the current website 888 * @param companyId the company ID 889 * @param classNameId the class name ID 890 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 891 * @return the previous, current, and next website 892 * @throws NoSuchWebsiteException if a website with the primary key could not be found 893 */ 894 public static Website[] findByC_C_PrevAndNext(long websiteId, 895 long companyId, long classNameId, 896 OrderByComparator<Website> orderByComparator) 897 throws com.liferay.portal.exception.NoSuchWebsiteException { 898 return getPersistence() 899 .findByC_C_PrevAndNext(websiteId, companyId, classNameId, 900 orderByComparator); 901 } 902 903 /** 904 * Removes all the websites where companyId = ? and classNameId = ? from the database. 905 * 906 * @param companyId the company ID 907 * @param classNameId the class name ID 908 */ 909 public static void removeByC_C(long companyId, long classNameId) { 910 getPersistence().removeByC_C(companyId, classNameId); 911 } 912 913 /** 914 * Returns the number of websites where companyId = ? and classNameId = ?. 915 * 916 * @param companyId the company ID 917 * @param classNameId the class name ID 918 * @return the number of matching websites 919 */ 920 public static int countByC_C(long companyId, long classNameId) { 921 return getPersistence().countByC_C(companyId, classNameId); 922 } 923 924 /** 925 * Returns all the websites where companyId = ? and classNameId = ? and classPK = ?. 926 * 927 * @param companyId the company ID 928 * @param classNameId the class name ID 929 * @param classPK the class p k 930 * @return the matching websites 931 */ 932 public static List<Website> findByC_C_C(long companyId, long classNameId, 933 long classPK) { 934 return getPersistence().findByC_C_C(companyId, classNameId, classPK); 935 } 936 937 /** 938 * Returns a range of all the websites where companyId = ? and classNameId = ? and classPK = ?. 939 * 940 * <p> 941 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 942 * </p> 943 * 944 * @param companyId the company ID 945 * @param classNameId the class name ID 946 * @param classPK the class p k 947 * @param start the lower bound of the range of websites 948 * @param end the upper bound of the range of websites (not inclusive) 949 * @return the range of matching websites 950 */ 951 public static List<Website> findByC_C_C(long companyId, long classNameId, 952 long classPK, int start, int end) { 953 return getPersistence() 954 .findByC_C_C(companyId, classNameId, classPK, start, end); 955 } 956 957 /** 958 * Returns an ordered range of all the websites where companyId = ? and classNameId = ? and classPK = ?. 959 * 960 * <p> 961 * 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. 962 * </p> 963 * 964 * @param companyId the company ID 965 * @param classNameId the class name ID 966 * @param classPK the class p k 967 * @param start the lower bound of the range of websites 968 * @param end the upper bound of the range of websites (not inclusive) 969 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 970 * @return the ordered range of matching websites 971 */ 972 public static List<Website> findByC_C_C(long companyId, long classNameId, 973 long classPK, int start, int end, 974 OrderByComparator<Website> orderByComparator) { 975 return getPersistence() 976 .findByC_C_C(companyId, classNameId, classPK, start, end, 977 orderByComparator); 978 } 979 980 /** 981 * Returns an ordered range of all the websites where companyId = ? and classNameId = ? and classPK = ?. 982 * 983 * <p> 984 * 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. 985 * </p> 986 * 987 * @param companyId the company ID 988 * @param classNameId the class name ID 989 * @param classPK the class p k 990 * @param start the lower bound of the range of websites 991 * @param end the upper bound of the range of websites (not inclusive) 992 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 993 * @param retrieveFromCache whether to retrieve from the finder cache 994 * @return the ordered range of matching websites 995 */ 996 public static List<Website> findByC_C_C(long companyId, long classNameId, 997 long classPK, int start, int end, 998 OrderByComparator<Website> orderByComparator, boolean retrieveFromCache) { 999 return getPersistence() 1000 .findByC_C_C(companyId, classNameId, classPK, start, end, 1001 orderByComparator, retrieveFromCache); 1002 } 1003 1004 /** 1005 * Returns the first website in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 1006 * 1007 * @param companyId the company ID 1008 * @param classNameId the class name ID 1009 * @param classPK the class p k 1010 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1011 * @return the first matching website 1012 * @throws NoSuchWebsiteException if a matching website could not be found 1013 */ 1014 public static Website findByC_C_C_First(long companyId, long classNameId, 1015 long classPK, OrderByComparator<Website> orderByComparator) 1016 throws com.liferay.portal.exception.NoSuchWebsiteException { 1017 return getPersistence() 1018 .findByC_C_C_First(companyId, classNameId, classPK, 1019 orderByComparator); 1020 } 1021 1022 /** 1023 * Returns the first website in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 1024 * 1025 * @param companyId the company ID 1026 * @param classNameId the class name ID 1027 * @param classPK the class p k 1028 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1029 * @return the first matching website, or <code>null</code> if a matching website could not be found 1030 */ 1031 public static Website fetchByC_C_C_First(long companyId, long classNameId, 1032 long classPK, OrderByComparator<Website> orderByComparator) { 1033 return getPersistence() 1034 .fetchByC_C_C_First(companyId, classNameId, classPK, 1035 orderByComparator); 1036 } 1037 1038 /** 1039 * Returns the last website in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 1040 * 1041 * @param companyId the company ID 1042 * @param classNameId the class name ID 1043 * @param classPK the class p k 1044 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1045 * @return the last matching website 1046 * @throws NoSuchWebsiteException if a matching website could not be found 1047 */ 1048 public static Website findByC_C_C_Last(long companyId, long classNameId, 1049 long classPK, OrderByComparator<Website> orderByComparator) 1050 throws com.liferay.portal.exception.NoSuchWebsiteException { 1051 return getPersistence() 1052 .findByC_C_C_Last(companyId, classNameId, classPK, 1053 orderByComparator); 1054 } 1055 1056 /** 1057 * Returns the last website in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 1058 * 1059 * @param companyId the company ID 1060 * @param classNameId the class name ID 1061 * @param classPK the class p k 1062 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1063 * @return the last matching website, or <code>null</code> if a matching website could not be found 1064 */ 1065 public static Website fetchByC_C_C_Last(long companyId, long classNameId, 1066 long classPK, OrderByComparator<Website> orderByComparator) { 1067 return getPersistence() 1068 .fetchByC_C_C_Last(companyId, classNameId, classPK, 1069 orderByComparator); 1070 } 1071 1072 /** 1073 * Returns the websites before and after the current website in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 1074 * 1075 * @param websiteId the primary key of the current website 1076 * @param companyId the company ID 1077 * @param classNameId the class name ID 1078 * @param classPK the class p k 1079 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1080 * @return the previous, current, and next website 1081 * @throws NoSuchWebsiteException if a website with the primary key could not be found 1082 */ 1083 public static Website[] findByC_C_C_PrevAndNext(long websiteId, 1084 long companyId, long classNameId, long classPK, 1085 OrderByComparator<Website> orderByComparator) 1086 throws com.liferay.portal.exception.NoSuchWebsiteException { 1087 return getPersistence() 1088 .findByC_C_C_PrevAndNext(websiteId, companyId, classNameId, 1089 classPK, orderByComparator); 1090 } 1091 1092 /** 1093 * Removes all the websites where companyId = ? and classNameId = ? and classPK = ? from the database. 1094 * 1095 * @param companyId the company ID 1096 * @param classNameId the class name ID 1097 * @param classPK the class p k 1098 */ 1099 public static void removeByC_C_C(long companyId, long classNameId, 1100 long classPK) { 1101 getPersistence().removeByC_C_C(companyId, classNameId, classPK); 1102 } 1103 1104 /** 1105 * Returns the number of websites where companyId = ? and classNameId = ? and classPK = ?. 1106 * 1107 * @param companyId the company ID 1108 * @param classNameId the class name ID 1109 * @param classPK the class p k 1110 * @return the number of matching websites 1111 */ 1112 public static int countByC_C_C(long companyId, long classNameId, 1113 long classPK) { 1114 return getPersistence().countByC_C_C(companyId, classNameId, classPK); 1115 } 1116 1117 /** 1118 * Returns all the websites where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1119 * 1120 * @param companyId the company ID 1121 * @param classNameId the class name ID 1122 * @param classPK the class p k 1123 * @param primary the primary 1124 * @return the matching websites 1125 */ 1126 public static List<Website> findByC_C_C_P(long companyId, long classNameId, 1127 long classPK, boolean primary) { 1128 return getPersistence() 1129 .findByC_C_C_P(companyId, classNameId, classPK, primary); 1130 } 1131 1132 /** 1133 * Returns a range of all the websites where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1134 * 1135 * <p> 1136 * 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. 1137 * </p> 1138 * 1139 * @param companyId the company ID 1140 * @param classNameId the class name ID 1141 * @param classPK the class p k 1142 * @param primary the primary 1143 * @param start the lower bound of the range of websites 1144 * @param end the upper bound of the range of websites (not inclusive) 1145 * @return the range of matching websites 1146 */ 1147 public static List<Website> findByC_C_C_P(long companyId, long classNameId, 1148 long classPK, boolean primary, int start, int end) { 1149 return getPersistence() 1150 .findByC_C_C_P(companyId, classNameId, classPK, primary, 1151 start, end); 1152 } 1153 1154 /** 1155 * Returns an ordered range of all the websites where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1156 * 1157 * <p> 1158 * 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. 1159 * </p> 1160 * 1161 * @param companyId the company ID 1162 * @param classNameId the class name ID 1163 * @param classPK the class p k 1164 * @param primary the primary 1165 * @param start the lower bound of the range of websites 1166 * @param end the upper bound of the range of websites (not inclusive) 1167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1168 * @return the ordered range of matching websites 1169 */ 1170 public static List<Website> findByC_C_C_P(long companyId, long classNameId, 1171 long classPK, boolean primary, int start, int end, 1172 OrderByComparator<Website> orderByComparator) { 1173 return getPersistence() 1174 .findByC_C_C_P(companyId, classNameId, classPK, primary, 1175 start, end, orderByComparator); 1176 } 1177 1178 /** 1179 * Returns an ordered range of all the websites where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1180 * 1181 * <p> 1182 * 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. 1183 * </p> 1184 * 1185 * @param companyId the company ID 1186 * @param classNameId the class name ID 1187 * @param classPK the class p k 1188 * @param primary the primary 1189 * @param start the lower bound of the range of websites 1190 * @param end the upper bound of the range of websites (not inclusive) 1191 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1192 * @param retrieveFromCache whether to retrieve from the finder cache 1193 * @return the ordered range of matching websites 1194 */ 1195 public static List<Website> findByC_C_C_P(long companyId, long classNameId, 1196 long classPK, boolean primary, int start, int end, 1197 OrderByComparator<Website> orderByComparator, boolean retrieveFromCache) { 1198 return getPersistence() 1199 .findByC_C_C_P(companyId, classNameId, classPK, primary, 1200 start, end, orderByComparator, retrieveFromCache); 1201 } 1202 1203 /** 1204 * Returns the first website in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1205 * 1206 * @param companyId the company ID 1207 * @param classNameId the class name ID 1208 * @param classPK the class p k 1209 * @param primary the primary 1210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1211 * @return the first matching website 1212 * @throws NoSuchWebsiteException if a matching website could not be found 1213 */ 1214 public static Website findByC_C_C_P_First(long companyId, long classNameId, 1215 long classPK, boolean primary, 1216 OrderByComparator<Website> orderByComparator) 1217 throws com.liferay.portal.exception.NoSuchWebsiteException { 1218 return getPersistence() 1219 .findByC_C_C_P_First(companyId, classNameId, classPK, 1220 primary, orderByComparator); 1221 } 1222 1223 /** 1224 * Returns the first website in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1225 * 1226 * @param companyId the company ID 1227 * @param classNameId the class name ID 1228 * @param classPK the class p k 1229 * @param primary the primary 1230 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1231 * @return the first matching website, or <code>null</code> if a matching website could not be found 1232 */ 1233 public static Website fetchByC_C_C_P_First(long companyId, 1234 long classNameId, long classPK, boolean primary, 1235 OrderByComparator<Website> orderByComparator) { 1236 return getPersistence() 1237 .fetchByC_C_C_P_First(companyId, classNameId, classPK, 1238 primary, orderByComparator); 1239 } 1240 1241 /** 1242 * Returns the last website in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1243 * 1244 * @param companyId the company ID 1245 * @param classNameId the class name ID 1246 * @param classPK the class p k 1247 * @param primary the primary 1248 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1249 * @return the last matching website 1250 * @throws NoSuchWebsiteException if a matching website could not be found 1251 */ 1252 public static Website findByC_C_C_P_Last(long companyId, long classNameId, 1253 long classPK, boolean primary, 1254 OrderByComparator<Website> orderByComparator) 1255 throws com.liferay.portal.exception.NoSuchWebsiteException { 1256 return getPersistence() 1257 .findByC_C_C_P_Last(companyId, classNameId, classPK, 1258 primary, orderByComparator); 1259 } 1260 1261 /** 1262 * Returns the last website in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1263 * 1264 * @param companyId the company ID 1265 * @param classNameId the class name ID 1266 * @param classPK the class p k 1267 * @param primary the primary 1268 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1269 * @return the last matching website, or <code>null</code> if a matching website could not be found 1270 */ 1271 public static Website fetchByC_C_C_P_Last(long companyId, long classNameId, 1272 long classPK, boolean primary, 1273 OrderByComparator<Website> orderByComparator) { 1274 return getPersistence() 1275 .fetchByC_C_C_P_Last(companyId, classNameId, classPK, 1276 primary, orderByComparator); 1277 } 1278 1279 /** 1280 * Returns the websites before and after the current website in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1281 * 1282 * @param websiteId the primary key of the current website 1283 * @param companyId the company ID 1284 * @param classNameId the class name ID 1285 * @param classPK the class p k 1286 * @param primary the primary 1287 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1288 * @return the previous, current, and next website 1289 * @throws NoSuchWebsiteException if a website with the primary key could not be found 1290 */ 1291 public static Website[] findByC_C_C_P_PrevAndNext(long websiteId, 1292 long companyId, long classNameId, long classPK, boolean primary, 1293 OrderByComparator<Website> orderByComparator) 1294 throws com.liferay.portal.exception.NoSuchWebsiteException { 1295 return getPersistence() 1296 .findByC_C_C_P_PrevAndNext(websiteId, companyId, 1297 classNameId, classPK, primary, orderByComparator); 1298 } 1299 1300 /** 1301 * Removes all the websites where companyId = ? and classNameId = ? and classPK = ? and primary = ? from the database. 1302 * 1303 * @param companyId the company ID 1304 * @param classNameId the class name ID 1305 * @param classPK the class p k 1306 * @param primary the primary 1307 */ 1308 public static void removeByC_C_C_P(long companyId, long classNameId, 1309 long classPK, boolean primary) { 1310 getPersistence() 1311 .removeByC_C_C_P(companyId, classNameId, classPK, primary); 1312 } 1313 1314 /** 1315 * Returns the number of websites where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1316 * 1317 * @param companyId the company ID 1318 * @param classNameId the class name ID 1319 * @param classPK the class p k 1320 * @param primary the primary 1321 * @return the number of matching websites 1322 */ 1323 public static int countByC_C_C_P(long companyId, long classNameId, 1324 long classPK, boolean primary) { 1325 return getPersistence() 1326 .countByC_C_C_P(companyId, classNameId, classPK, primary); 1327 } 1328 1329 /** 1330 * Caches the website in the entity cache if it is enabled. 1331 * 1332 * @param website the website 1333 */ 1334 public static void cacheResult(Website website) { 1335 getPersistence().cacheResult(website); 1336 } 1337 1338 /** 1339 * Caches the websites in the entity cache if it is enabled. 1340 * 1341 * @param websites the websites 1342 */ 1343 public static void cacheResult(List<Website> websites) { 1344 getPersistence().cacheResult(websites); 1345 } 1346 1347 /** 1348 * Creates a new website with the primary key. Does not add the website to the database. 1349 * 1350 * @param websiteId the primary key for the new website 1351 * @return the new website 1352 */ 1353 public static Website create(long websiteId) { 1354 return getPersistence().create(websiteId); 1355 } 1356 1357 /** 1358 * Removes the website with the primary key from the database. Also notifies the appropriate model listeners. 1359 * 1360 * @param websiteId the primary key of the website 1361 * @return the website that was removed 1362 * @throws NoSuchWebsiteException if a website with the primary key could not be found 1363 */ 1364 public static Website remove(long websiteId) 1365 throws com.liferay.portal.exception.NoSuchWebsiteException { 1366 return getPersistence().remove(websiteId); 1367 } 1368 1369 public static Website updateImpl(Website website) { 1370 return getPersistence().updateImpl(website); 1371 } 1372 1373 /** 1374 * Returns the website with the primary key or throws a {@link NoSuchWebsiteException} if it could not be found. 1375 * 1376 * @param websiteId the primary key of the website 1377 * @return the website 1378 * @throws NoSuchWebsiteException if a website with the primary key could not be found 1379 */ 1380 public static Website findByPrimaryKey(long websiteId) 1381 throws com.liferay.portal.exception.NoSuchWebsiteException { 1382 return getPersistence().findByPrimaryKey(websiteId); 1383 } 1384 1385 /** 1386 * Returns the website with the primary key or returns <code>null</code> if it could not be found. 1387 * 1388 * @param websiteId the primary key of the website 1389 * @return the website, or <code>null</code> if a website with the primary key could not be found 1390 */ 1391 public static Website fetchByPrimaryKey(long websiteId) { 1392 return getPersistence().fetchByPrimaryKey(websiteId); 1393 } 1394 1395 public static java.util.Map<java.io.Serializable, Website> fetchByPrimaryKeys( 1396 java.util.Set<java.io.Serializable> primaryKeys) { 1397 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1398 } 1399 1400 /** 1401 * Returns all the websites. 1402 * 1403 * @return the websites 1404 */ 1405 public static List<Website> findAll() { 1406 return getPersistence().findAll(); 1407 } 1408 1409 /** 1410 * Returns a range of all the websites. 1411 * 1412 * <p> 1413 * 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. 1414 * </p> 1415 * 1416 * @param start the lower bound of the range of websites 1417 * @param end the upper bound of the range of websites (not inclusive) 1418 * @return the range of websites 1419 */ 1420 public static List<Website> findAll(int start, int end) { 1421 return getPersistence().findAll(start, end); 1422 } 1423 1424 /** 1425 * Returns an ordered range of all the websites. 1426 * 1427 * <p> 1428 * 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. 1429 * </p> 1430 * 1431 * @param start the lower bound of the range of websites 1432 * @param end the upper bound of the range of websites (not inclusive) 1433 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1434 * @return the ordered range of websites 1435 */ 1436 public static List<Website> findAll(int start, int end, 1437 OrderByComparator<Website> orderByComparator) { 1438 return getPersistence().findAll(start, end, orderByComparator); 1439 } 1440 1441 /** 1442 * Returns an ordered range of all the websites. 1443 * 1444 * <p> 1445 * 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. 1446 * </p> 1447 * 1448 * @param start the lower bound of the range of websites 1449 * @param end the upper bound of the range of websites (not inclusive) 1450 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1451 * @param retrieveFromCache whether to retrieve from the finder cache 1452 * @return the ordered range of websites 1453 */ 1454 public static List<Website> findAll(int start, int end, 1455 OrderByComparator<Website> orderByComparator, boolean retrieveFromCache) { 1456 return getPersistence() 1457 .findAll(start, end, orderByComparator, retrieveFromCache); 1458 } 1459 1460 /** 1461 * Removes all the websites from the database. 1462 */ 1463 public static void removeAll() { 1464 getPersistence().removeAll(); 1465 } 1466 1467 /** 1468 * Returns the number of websites. 1469 * 1470 * @return the number of websites 1471 */ 1472 public static int countAll() { 1473 return getPersistence().countAll(); 1474 } 1475 1476 public static java.util.Set<java.lang.String> getBadColumnNames() { 1477 return getPersistence().getBadColumnNames(); 1478 } 1479 1480 public static WebsitePersistence getPersistence() { 1481 if (_persistence == null) { 1482 _persistence = (WebsitePersistence)PortalBeanLocatorUtil.locate(WebsitePersistence.class.getName()); 1483 1484 ReferenceRegistry.registerReference(WebsiteUtil.class, 1485 "_persistence"); 1486 } 1487 1488 return _persistence; 1489 } 1490 1491 private static WebsitePersistence _persistence; 1492 }