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.PasswordPolicy; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the password policy service. This utility wraps {@link com.liferay.portal.service.persistence.impl.PasswordPolicyPersistenceImpl} 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 PasswordPolicyPersistence 037 * @see com.liferay.portal.service.persistence.impl.PasswordPolicyPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class PasswordPolicyUtil { 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(PasswordPolicy passwordPolicy) { 059 getPersistence().clearCache(passwordPolicy); 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<PasswordPolicy> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<PasswordPolicy> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<PasswordPolicy> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<PasswordPolicy> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static PasswordPolicy update(PasswordPolicy passwordPolicy) { 100 return getPersistence().update(passwordPolicy); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static PasswordPolicy update(PasswordPolicy passwordPolicy, 107 ServiceContext serviceContext) { 108 return getPersistence().update(passwordPolicy, serviceContext); 109 } 110 111 /** 112 * Returns all the password policies where uuid = ?. 113 * 114 * @param uuid the uuid 115 * @return the matching password policies 116 */ 117 public static List<PasswordPolicy> findByUuid(java.lang.String uuid) { 118 return getPersistence().findByUuid(uuid); 119 } 120 121 /** 122 * Returns a range of all the password policies where uuid = ?. 123 * 124 * <p> 125 * 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 PasswordPolicyModelImpl}. 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. 126 * </p> 127 * 128 * @param uuid the uuid 129 * @param start the lower bound of the range of password policies 130 * @param end the upper bound of the range of password policies (not inclusive) 131 * @return the range of matching password policies 132 */ 133 public static List<PasswordPolicy> findByUuid(java.lang.String uuid, 134 int start, int end) { 135 return getPersistence().findByUuid(uuid, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the password policies where uuid = ?. 140 * 141 * <p> 142 * 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 PasswordPolicyModelImpl}. 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. 143 * </p> 144 * 145 * @param uuid the uuid 146 * @param start the lower bound of the range of password policies 147 * @param end the upper bound of the range of password policies (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching password policies 150 */ 151 public static List<PasswordPolicy> findByUuid(java.lang.String uuid, 152 int start, int end, OrderByComparator<PasswordPolicy> orderByComparator) { 153 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 154 } 155 156 /** 157 * Returns an ordered range of all the password policies where uuid = ?. 158 * 159 * <p> 160 * 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 PasswordPolicyModelImpl}. 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. 161 * </p> 162 * 163 * @param uuid the uuid 164 * @param start the lower bound of the range of password policies 165 * @param end the upper bound of the range of password policies (not inclusive) 166 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 167 * @param retrieveFromCache whether to retrieve from the finder cache 168 * @return the ordered range of matching password policies 169 */ 170 public static List<PasswordPolicy> findByUuid(java.lang.String uuid, 171 int start, int end, 172 OrderByComparator<PasswordPolicy> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByUuid(uuid, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first password policy in the ordered set where uuid = ?. 181 * 182 * @param uuid the uuid 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching password policy 185 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 186 */ 187 public static PasswordPolicy findByUuid_First(java.lang.String uuid, 188 OrderByComparator<PasswordPolicy> orderByComparator) 189 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 190 return getPersistence().findByUuid_First(uuid, orderByComparator); 191 } 192 193 /** 194 * Returns the first password policy in the ordered set where uuid = ?. 195 * 196 * @param uuid the uuid 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 199 */ 200 public static PasswordPolicy fetchByUuid_First(java.lang.String uuid, 201 OrderByComparator<PasswordPolicy> orderByComparator) { 202 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 203 } 204 205 /** 206 * Returns the last password policy in the ordered set where uuid = ?. 207 * 208 * @param uuid the uuid 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching password policy 211 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 212 */ 213 public static PasswordPolicy findByUuid_Last(java.lang.String uuid, 214 OrderByComparator<PasswordPolicy> orderByComparator) 215 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 216 return getPersistence().findByUuid_Last(uuid, orderByComparator); 217 } 218 219 /** 220 * Returns the last password policy in the ordered set where uuid = ?. 221 * 222 * @param uuid the uuid 223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 224 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 225 */ 226 public static PasswordPolicy fetchByUuid_Last(java.lang.String uuid, 227 OrderByComparator<PasswordPolicy> orderByComparator) { 228 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 229 } 230 231 /** 232 * Returns the password policies before and after the current password policy in the ordered set where uuid = ?. 233 * 234 * @param passwordPolicyId the primary key of the current password policy 235 * @param uuid the uuid 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next password policy 238 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 239 */ 240 public static PasswordPolicy[] findByUuid_PrevAndNext( 241 long passwordPolicyId, java.lang.String uuid, 242 OrderByComparator<PasswordPolicy> orderByComparator) 243 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 244 return getPersistence() 245 .findByUuid_PrevAndNext(passwordPolicyId, uuid, 246 orderByComparator); 247 } 248 249 /** 250 * Returns all the password policies that the user has permission to view where uuid = ?. 251 * 252 * @param uuid the uuid 253 * @return the matching password policies that the user has permission to view 254 */ 255 public static List<PasswordPolicy> filterFindByUuid(java.lang.String uuid) { 256 return getPersistence().filterFindByUuid(uuid); 257 } 258 259 /** 260 * Returns a range of all the password policies that the user has permission to view where uuid = ?. 261 * 262 * <p> 263 * 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 PasswordPolicyModelImpl}. 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. 264 * </p> 265 * 266 * @param uuid the uuid 267 * @param start the lower bound of the range of password policies 268 * @param end the upper bound of the range of password policies (not inclusive) 269 * @return the range of matching password policies that the user has permission to view 270 */ 271 public static List<PasswordPolicy> filterFindByUuid(java.lang.String uuid, 272 int start, int end) { 273 return getPersistence().filterFindByUuid(uuid, start, end); 274 } 275 276 /** 277 * Returns an ordered range of all the password policies that the user has permissions to view where uuid = ?. 278 * 279 * <p> 280 * 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 PasswordPolicyModelImpl}. 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. 281 * </p> 282 * 283 * @param uuid the uuid 284 * @param start the lower bound of the range of password policies 285 * @param end the upper bound of the range of password policies (not inclusive) 286 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 287 * @return the ordered range of matching password policies that the user has permission to view 288 */ 289 public static List<PasswordPolicy> filterFindByUuid(java.lang.String uuid, 290 int start, int end, OrderByComparator<PasswordPolicy> orderByComparator) { 291 return getPersistence() 292 .filterFindByUuid(uuid, start, end, orderByComparator); 293 } 294 295 /** 296 * Returns the password policies before and after the current password policy in the ordered set of password policies that the user has permission to view where uuid = ?. 297 * 298 * @param passwordPolicyId the primary key of the current password policy 299 * @param uuid the uuid 300 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 301 * @return the previous, current, and next password policy 302 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 303 */ 304 public static PasswordPolicy[] filterFindByUuid_PrevAndNext( 305 long passwordPolicyId, java.lang.String uuid, 306 OrderByComparator<PasswordPolicy> orderByComparator) 307 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 308 return getPersistence() 309 .filterFindByUuid_PrevAndNext(passwordPolicyId, uuid, 310 orderByComparator); 311 } 312 313 /** 314 * Removes all the password policies where uuid = ? from the database. 315 * 316 * @param uuid the uuid 317 */ 318 public static void removeByUuid(java.lang.String uuid) { 319 getPersistence().removeByUuid(uuid); 320 } 321 322 /** 323 * Returns the number of password policies where uuid = ?. 324 * 325 * @param uuid the uuid 326 * @return the number of matching password policies 327 */ 328 public static int countByUuid(java.lang.String uuid) { 329 return getPersistence().countByUuid(uuid); 330 } 331 332 /** 333 * Returns the number of password policies that the user has permission to view where uuid = ?. 334 * 335 * @param uuid the uuid 336 * @return the number of matching password policies that the user has permission to view 337 */ 338 public static int filterCountByUuid(java.lang.String uuid) { 339 return getPersistence().filterCountByUuid(uuid); 340 } 341 342 /** 343 * Returns all the password policies where uuid = ? and companyId = ?. 344 * 345 * @param uuid the uuid 346 * @param companyId the company ID 347 * @return the matching password policies 348 */ 349 public static List<PasswordPolicy> findByUuid_C(java.lang.String uuid, 350 long companyId) { 351 return getPersistence().findByUuid_C(uuid, companyId); 352 } 353 354 /** 355 * Returns a range of all the password policies where uuid = ? and companyId = ?. 356 * 357 * <p> 358 * 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 PasswordPolicyModelImpl}. 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. 359 * </p> 360 * 361 * @param uuid the uuid 362 * @param companyId the company ID 363 * @param start the lower bound of the range of password policies 364 * @param end the upper bound of the range of password policies (not inclusive) 365 * @return the range of matching password policies 366 */ 367 public static List<PasswordPolicy> findByUuid_C(java.lang.String uuid, 368 long companyId, int start, int end) { 369 return getPersistence().findByUuid_C(uuid, companyId, start, end); 370 } 371 372 /** 373 * Returns an ordered range of all the password policies where uuid = ? and companyId = ?. 374 * 375 * <p> 376 * 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 PasswordPolicyModelImpl}. 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. 377 * </p> 378 * 379 * @param uuid the uuid 380 * @param companyId the company ID 381 * @param start the lower bound of the range of password policies 382 * @param end the upper bound of the range of password policies (not inclusive) 383 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 384 * @return the ordered range of matching password policies 385 */ 386 public static List<PasswordPolicy> findByUuid_C(java.lang.String uuid, 387 long companyId, int start, int end, 388 OrderByComparator<PasswordPolicy> orderByComparator) { 389 return getPersistence() 390 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 391 } 392 393 /** 394 * Returns an ordered range of all the password policies where uuid = ? and companyId = ?. 395 * 396 * <p> 397 * 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 PasswordPolicyModelImpl}. 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. 398 * </p> 399 * 400 * @param uuid the uuid 401 * @param companyId the company ID 402 * @param start the lower bound of the range of password policies 403 * @param end the upper bound of the range of password policies (not inclusive) 404 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 405 * @param retrieveFromCache whether to retrieve from the finder cache 406 * @return the ordered range of matching password policies 407 */ 408 public static List<PasswordPolicy> findByUuid_C(java.lang.String uuid, 409 long companyId, int start, int end, 410 OrderByComparator<PasswordPolicy> orderByComparator, 411 boolean retrieveFromCache) { 412 return getPersistence() 413 .findByUuid_C(uuid, companyId, start, end, 414 orderByComparator, retrieveFromCache); 415 } 416 417 /** 418 * Returns the first password policy in the ordered set where uuid = ? and companyId = ?. 419 * 420 * @param uuid the uuid 421 * @param companyId the company ID 422 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 423 * @return the first matching password policy 424 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 425 */ 426 public static PasswordPolicy findByUuid_C_First(java.lang.String uuid, 427 long companyId, OrderByComparator<PasswordPolicy> orderByComparator) 428 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 429 return getPersistence() 430 .findByUuid_C_First(uuid, companyId, orderByComparator); 431 } 432 433 /** 434 * Returns the first password policy in the ordered set where uuid = ? and companyId = ?. 435 * 436 * @param uuid the uuid 437 * @param companyId the company ID 438 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 439 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 440 */ 441 public static PasswordPolicy fetchByUuid_C_First(java.lang.String uuid, 442 long companyId, OrderByComparator<PasswordPolicy> orderByComparator) { 443 return getPersistence() 444 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 445 } 446 447 /** 448 * Returns the last password policy in the ordered set where uuid = ? and companyId = ?. 449 * 450 * @param uuid the uuid 451 * @param companyId the company ID 452 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 453 * @return the last matching password policy 454 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 455 */ 456 public static PasswordPolicy findByUuid_C_Last(java.lang.String uuid, 457 long companyId, OrderByComparator<PasswordPolicy> orderByComparator) 458 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 459 return getPersistence() 460 .findByUuid_C_Last(uuid, companyId, orderByComparator); 461 } 462 463 /** 464 * Returns the last password policy in the ordered set where uuid = ? and companyId = ?. 465 * 466 * @param uuid the uuid 467 * @param companyId the company ID 468 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 469 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 470 */ 471 public static PasswordPolicy fetchByUuid_C_Last(java.lang.String uuid, 472 long companyId, OrderByComparator<PasswordPolicy> orderByComparator) { 473 return getPersistence() 474 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 475 } 476 477 /** 478 * Returns the password policies before and after the current password policy in the ordered set where uuid = ? and companyId = ?. 479 * 480 * @param passwordPolicyId the primary key of the current password policy 481 * @param uuid the uuid 482 * @param companyId the company ID 483 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 484 * @return the previous, current, and next password policy 485 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 486 */ 487 public static PasswordPolicy[] findByUuid_C_PrevAndNext( 488 long passwordPolicyId, java.lang.String uuid, long companyId, 489 OrderByComparator<PasswordPolicy> orderByComparator) 490 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 491 return getPersistence() 492 .findByUuid_C_PrevAndNext(passwordPolicyId, uuid, companyId, 493 orderByComparator); 494 } 495 496 /** 497 * Returns all the password policies that the user has permission to view where uuid = ? and companyId = ?. 498 * 499 * @param uuid the uuid 500 * @param companyId the company ID 501 * @return the matching password policies that the user has permission to view 502 */ 503 public static List<PasswordPolicy> filterFindByUuid_C( 504 java.lang.String uuid, long companyId) { 505 return getPersistence().filterFindByUuid_C(uuid, companyId); 506 } 507 508 /** 509 * Returns a range of all the password policies that the user has permission to view where uuid = ? and companyId = ?. 510 * 511 * <p> 512 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 513 * </p> 514 * 515 * @param uuid the uuid 516 * @param companyId the company ID 517 * @param start the lower bound of the range of password policies 518 * @param end the upper bound of the range of password policies (not inclusive) 519 * @return the range of matching password policies that the user has permission to view 520 */ 521 public static List<PasswordPolicy> filterFindByUuid_C( 522 java.lang.String uuid, long companyId, int start, int end) { 523 return getPersistence().filterFindByUuid_C(uuid, companyId, start, end); 524 } 525 526 /** 527 * Returns an ordered range of all the password policies that the user has permissions to view where uuid = ? and companyId = ?. 528 * 529 * <p> 530 * 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 PasswordPolicyModelImpl}. 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. 531 * </p> 532 * 533 * @param uuid the uuid 534 * @param companyId the company ID 535 * @param start the lower bound of the range of password policies 536 * @param end the upper bound of the range of password policies (not inclusive) 537 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 538 * @return the ordered range of matching password policies that the user has permission to view 539 */ 540 public static List<PasswordPolicy> filterFindByUuid_C( 541 java.lang.String uuid, long companyId, int start, int end, 542 OrderByComparator<PasswordPolicy> orderByComparator) { 543 return getPersistence() 544 .filterFindByUuid_C(uuid, companyId, start, end, 545 orderByComparator); 546 } 547 548 /** 549 * Returns the password policies before and after the current password policy in the ordered set of password policies that the user has permission to view where uuid = ? and companyId = ?. 550 * 551 * @param passwordPolicyId the primary key of the current password policy 552 * @param uuid the uuid 553 * @param companyId the company ID 554 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 555 * @return the previous, current, and next password policy 556 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 557 */ 558 public static PasswordPolicy[] filterFindByUuid_C_PrevAndNext( 559 long passwordPolicyId, java.lang.String uuid, long companyId, 560 OrderByComparator<PasswordPolicy> orderByComparator) 561 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 562 return getPersistence() 563 .filterFindByUuid_C_PrevAndNext(passwordPolicyId, uuid, 564 companyId, orderByComparator); 565 } 566 567 /** 568 * Removes all the password policies where uuid = ? and companyId = ? from the database. 569 * 570 * @param uuid the uuid 571 * @param companyId the company ID 572 */ 573 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 574 getPersistence().removeByUuid_C(uuid, companyId); 575 } 576 577 /** 578 * Returns the number of password policies where uuid = ? and companyId = ?. 579 * 580 * @param uuid the uuid 581 * @param companyId the company ID 582 * @return the number of matching password policies 583 */ 584 public static int countByUuid_C(java.lang.String uuid, long companyId) { 585 return getPersistence().countByUuid_C(uuid, companyId); 586 } 587 588 /** 589 * Returns the number of password policies that the user has permission to view where uuid = ? and companyId = ?. 590 * 591 * @param uuid the uuid 592 * @param companyId the company ID 593 * @return the number of matching password policies that the user has permission to view 594 */ 595 public static int filterCountByUuid_C(java.lang.String uuid, long companyId) { 596 return getPersistence().filterCountByUuid_C(uuid, companyId); 597 } 598 599 /** 600 * Returns all the password policies where companyId = ?. 601 * 602 * @param companyId the company ID 603 * @return the matching password policies 604 */ 605 public static List<PasswordPolicy> findByCompanyId(long companyId) { 606 return getPersistence().findByCompanyId(companyId); 607 } 608 609 /** 610 * Returns a range of all the password policies where companyId = ?. 611 * 612 * <p> 613 * 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 PasswordPolicyModelImpl}. 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. 614 * </p> 615 * 616 * @param companyId the company ID 617 * @param start the lower bound of the range of password policies 618 * @param end the upper bound of the range of password policies (not inclusive) 619 * @return the range of matching password policies 620 */ 621 public static List<PasswordPolicy> findByCompanyId(long companyId, 622 int start, int end) { 623 return getPersistence().findByCompanyId(companyId, start, end); 624 } 625 626 /** 627 * Returns an ordered range of all the password policies where companyId = ?. 628 * 629 * <p> 630 * 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 PasswordPolicyModelImpl}. 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. 631 * </p> 632 * 633 * @param companyId the company ID 634 * @param start the lower bound of the range of password policies 635 * @param end the upper bound of the range of password policies (not inclusive) 636 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 637 * @return the ordered range of matching password policies 638 */ 639 public static List<PasswordPolicy> findByCompanyId(long companyId, 640 int start, int end, OrderByComparator<PasswordPolicy> orderByComparator) { 641 return getPersistence() 642 .findByCompanyId(companyId, start, end, orderByComparator); 643 } 644 645 /** 646 * Returns an ordered range of all the password policies where companyId = ?. 647 * 648 * <p> 649 * 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 PasswordPolicyModelImpl}. 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. 650 * </p> 651 * 652 * @param companyId the company ID 653 * @param start the lower bound of the range of password policies 654 * @param end the upper bound of the range of password policies (not inclusive) 655 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 656 * @param retrieveFromCache whether to retrieve from the finder cache 657 * @return the ordered range of matching password policies 658 */ 659 public static List<PasswordPolicy> findByCompanyId(long companyId, 660 int start, int end, 661 OrderByComparator<PasswordPolicy> orderByComparator, 662 boolean retrieveFromCache) { 663 return getPersistence() 664 .findByCompanyId(companyId, start, end, orderByComparator, 665 retrieveFromCache); 666 } 667 668 /** 669 * Returns the first password policy in the ordered set where companyId = ?. 670 * 671 * @param companyId the company ID 672 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 673 * @return the first matching password policy 674 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 675 */ 676 public static PasswordPolicy findByCompanyId_First(long companyId, 677 OrderByComparator<PasswordPolicy> orderByComparator) 678 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 679 return getPersistence() 680 .findByCompanyId_First(companyId, orderByComparator); 681 } 682 683 /** 684 * Returns the first password policy in the ordered set where companyId = ?. 685 * 686 * @param companyId the company ID 687 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 688 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 689 */ 690 public static PasswordPolicy fetchByCompanyId_First(long companyId, 691 OrderByComparator<PasswordPolicy> orderByComparator) { 692 return getPersistence() 693 .fetchByCompanyId_First(companyId, orderByComparator); 694 } 695 696 /** 697 * Returns the last password policy in the ordered set where companyId = ?. 698 * 699 * @param companyId the company ID 700 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 701 * @return the last matching password policy 702 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 703 */ 704 public static PasswordPolicy findByCompanyId_Last(long companyId, 705 OrderByComparator<PasswordPolicy> orderByComparator) 706 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 707 return getPersistence() 708 .findByCompanyId_Last(companyId, orderByComparator); 709 } 710 711 /** 712 * Returns the last password policy in the ordered set where companyId = ?. 713 * 714 * @param companyId the company ID 715 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 716 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 717 */ 718 public static PasswordPolicy fetchByCompanyId_Last(long companyId, 719 OrderByComparator<PasswordPolicy> orderByComparator) { 720 return getPersistence() 721 .fetchByCompanyId_Last(companyId, orderByComparator); 722 } 723 724 /** 725 * Returns the password policies before and after the current password policy in the ordered set where companyId = ?. 726 * 727 * @param passwordPolicyId the primary key of the current password policy 728 * @param companyId the company ID 729 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 730 * @return the previous, current, and next password policy 731 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 732 */ 733 public static PasswordPolicy[] findByCompanyId_PrevAndNext( 734 long passwordPolicyId, long companyId, 735 OrderByComparator<PasswordPolicy> orderByComparator) 736 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 737 return getPersistence() 738 .findByCompanyId_PrevAndNext(passwordPolicyId, companyId, 739 orderByComparator); 740 } 741 742 /** 743 * Returns all the password policies that the user has permission to view where companyId = ?. 744 * 745 * @param companyId the company ID 746 * @return the matching password policies that the user has permission to view 747 */ 748 public static List<PasswordPolicy> filterFindByCompanyId(long companyId) { 749 return getPersistence().filterFindByCompanyId(companyId); 750 } 751 752 /** 753 * Returns a range of all the password policies that the user has permission to view where companyId = ?. 754 * 755 * <p> 756 * 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 PasswordPolicyModelImpl}. 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. 757 * </p> 758 * 759 * @param companyId the company ID 760 * @param start the lower bound of the range of password policies 761 * @param end the upper bound of the range of password policies (not inclusive) 762 * @return the range of matching password policies that the user has permission to view 763 */ 764 public static List<PasswordPolicy> filterFindByCompanyId(long companyId, 765 int start, int end) { 766 return getPersistence().filterFindByCompanyId(companyId, start, end); 767 } 768 769 /** 770 * Returns an ordered range of all the password policies that the user has permissions to view where companyId = ?. 771 * 772 * <p> 773 * 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 PasswordPolicyModelImpl}. 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. 774 * </p> 775 * 776 * @param companyId the company ID 777 * @param start the lower bound of the range of password policies 778 * @param end the upper bound of the range of password policies (not inclusive) 779 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 780 * @return the ordered range of matching password policies that the user has permission to view 781 */ 782 public static List<PasswordPolicy> filterFindByCompanyId(long companyId, 783 int start, int end, OrderByComparator<PasswordPolicy> orderByComparator) { 784 return getPersistence() 785 .filterFindByCompanyId(companyId, start, end, 786 orderByComparator); 787 } 788 789 /** 790 * Returns the password policies before and after the current password policy in the ordered set of password policies that the user has permission to view where companyId = ?. 791 * 792 * @param passwordPolicyId the primary key of the current password policy 793 * @param companyId the company ID 794 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 795 * @return the previous, current, and next password policy 796 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 797 */ 798 public static PasswordPolicy[] filterFindByCompanyId_PrevAndNext( 799 long passwordPolicyId, long companyId, 800 OrderByComparator<PasswordPolicy> orderByComparator) 801 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 802 return getPersistence() 803 .filterFindByCompanyId_PrevAndNext(passwordPolicyId, 804 companyId, orderByComparator); 805 } 806 807 /** 808 * Removes all the password policies where companyId = ? from the database. 809 * 810 * @param companyId the company ID 811 */ 812 public static void removeByCompanyId(long companyId) { 813 getPersistence().removeByCompanyId(companyId); 814 } 815 816 /** 817 * Returns the number of password policies where companyId = ?. 818 * 819 * @param companyId the company ID 820 * @return the number of matching password policies 821 */ 822 public static int countByCompanyId(long companyId) { 823 return getPersistence().countByCompanyId(companyId); 824 } 825 826 /** 827 * Returns the number of password policies that the user has permission to view where companyId = ?. 828 * 829 * @param companyId the company ID 830 * @return the number of matching password policies that the user has permission to view 831 */ 832 public static int filterCountByCompanyId(long companyId) { 833 return getPersistence().filterCountByCompanyId(companyId); 834 } 835 836 /** 837 * Returns the password policy where companyId = ? and defaultPolicy = ? or throws a {@link NoSuchPasswordPolicyException} if it could not be found. 838 * 839 * @param companyId the company ID 840 * @param defaultPolicy the default policy 841 * @return the matching password policy 842 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 843 */ 844 public static PasswordPolicy findByC_DP(long companyId, 845 boolean defaultPolicy) 846 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 847 return getPersistence().findByC_DP(companyId, defaultPolicy); 848 } 849 850 /** 851 * Returns the password policy where companyId = ? and defaultPolicy = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 852 * 853 * @param companyId the company ID 854 * @param defaultPolicy the default policy 855 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 856 */ 857 public static PasswordPolicy fetchByC_DP(long companyId, 858 boolean defaultPolicy) { 859 return getPersistence().fetchByC_DP(companyId, defaultPolicy); 860 } 861 862 /** 863 * Returns the password policy where companyId = ? and defaultPolicy = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 864 * 865 * @param companyId the company ID 866 * @param defaultPolicy the default policy 867 * @param retrieveFromCache whether to retrieve from the finder cache 868 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 869 */ 870 public static PasswordPolicy fetchByC_DP(long companyId, 871 boolean defaultPolicy, boolean retrieveFromCache) { 872 return getPersistence() 873 .fetchByC_DP(companyId, defaultPolicy, retrieveFromCache); 874 } 875 876 /** 877 * Removes the password policy where companyId = ? and defaultPolicy = ? from the database. 878 * 879 * @param companyId the company ID 880 * @param defaultPolicy the default policy 881 * @return the password policy that was removed 882 */ 883 public static PasswordPolicy removeByC_DP(long companyId, 884 boolean defaultPolicy) 885 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 886 return getPersistence().removeByC_DP(companyId, defaultPolicy); 887 } 888 889 /** 890 * Returns the number of password policies where companyId = ? and defaultPolicy = ?. 891 * 892 * @param companyId the company ID 893 * @param defaultPolicy the default policy 894 * @return the number of matching password policies 895 */ 896 public static int countByC_DP(long companyId, boolean defaultPolicy) { 897 return getPersistence().countByC_DP(companyId, defaultPolicy); 898 } 899 900 /** 901 * Returns the password policy where companyId = ? and name = ? or throws a {@link NoSuchPasswordPolicyException} if it could not be found. 902 * 903 * @param companyId the company ID 904 * @param name the name 905 * @return the matching password policy 906 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 907 */ 908 public static PasswordPolicy findByC_N(long companyId, java.lang.String name) 909 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 910 return getPersistence().findByC_N(companyId, name); 911 } 912 913 /** 914 * Returns the password policy where companyId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 915 * 916 * @param companyId the company ID 917 * @param name the name 918 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 919 */ 920 public static PasswordPolicy fetchByC_N(long companyId, 921 java.lang.String name) { 922 return getPersistence().fetchByC_N(companyId, name); 923 } 924 925 /** 926 * Returns the password policy where companyId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 927 * 928 * @param companyId the company ID 929 * @param name the name 930 * @param retrieveFromCache whether to retrieve from the finder cache 931 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 932 */ 933 public static PasswordPolicy fetchByC_N(long companyId, 934 java.lang.String name, boolean retrieveFromCache) { 935 return getPersistence().fetchByC_N(companyId, name, retrieveFromCache); 936 } 937 938 /** 939 * Removes the password policy where companyId = ? and name = ? from the database. 940 * 941 * @param companyId the company ID 942 * @param name the name 943 * @return the password policy that was removed 944 */ 945 public static PasswordPolicy removeByC_N(long companyId, 946 java.lang.String name) 947 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 948 return getPersistence().removeByC_N(companyId, name); 949 } 950 951 /** 952 * Returns the number of password policies where companyId = ? and name = ?. 953 * 954 * @param companyId the company ID 955 * @param name the name 956 * @return the number of matching password policies 957 */ 958 public static int countByC_N(long companyId, java.lang.String name) { 959 return getPersistence().countByC_N(companyId, name); 960 } 961 962 /** 963 * Caches the password policy in the entity cache if it is enabled. 964 * 965 * @param passwordPolicy the password policy 966 */ 967 public static void cacheResult(PasswordPolicy passwordPolicy) { 968 getPersistence().cacheResult(passwordPolicy); 969 } 970 971 /** 972 * Caches the password policies in the entity cache if it is enabled. 973 * 974 * @param passwordPolicies the password policies 975 */ 976 public static void cacheResult(List<PasswordPolicy> passwordPolicies) { 977 getPersistence().cacheResult(passwordPolicies); 978 } 979 980 /** 981 * Creates a new password policy with the primary key. Does not add the password policy to the database. 982 * 983 * @param passwordPolicyId the primary key for the new password policy 984 * @return the new password policy 985 */ 986 public static PasswordPolicy create(long passwordPolicyId) { 987 return getPersistence().create(passwordPolicyId); 988 } 989 990 /** 991 * Removes the password policy with the primary key from the database. Also notifies the appropriate model listeners. 992 * 993 * @param passwordPolicyId the primary key of the password policy 994 * @return the password policy that was removed 995 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 996 */ 997 public static PasswordPolicy remove(long passwordPolicyId) 998 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 999 return getPersistence().remove(passwordPolicyId); 1000 } 1001 1002 public static PasswordPolicy updateImpl(PasswordPolicy passwordPolicy) { 1003 return getPersistence().updateImpl(passwordPolicy); 1004 } 1005 1006 /** 1007 * Returns the password policy with the primary key or throws a {@link NoSuchPasswordPolicyException} if it could not be found. 1008 * 1009 * @param passwordPolicyId the primary key of the password policy 1010 * @return the password policy 1011 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 1012 */ 1013 public static PasswordPolicy findByPrimaryKey(long passwordPolicyId) 1014 throws com.liferay.portal.exception.NoSuchPasswordPolicyException { 1015 return getPersistence().findByPrimaryKey(passwordPolicyId); 1016 } 1017 1018 /** 1019 * Returns the password policy with the primary key or returns <code>null</code> if it could not be found. 1020 * 1021 * @param passwordPolicyId the primary key of the password policy 1022 * @return the password policy, or <code>null</code> if a password policy with the primary key could not be found 1023 */ 1024 public static PasswordPolicy fetchByPrimaryKey(long passwordPolicyId) { 1025 return getPersistence().fetchByPrimaryKey(passwordPolicyId); 1026 } 1027 1028 public static java.util.Map<java.io.Serializable, PasswordPolicy> fetchByPrimaryKeys( 1029 java.util.Set<java.io.Serializable> primaryKeys) { 1030 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1031 } 1032 1033 /** 1034 * Returns all the password policies. 1035 * 1036 * @return the password policies 1037 */ 1038 public static List<PasswordPolicy> findAll() { 1039 return getPersistence().findAll(); 1040 } 1041 1042 /** 1043 * Returns a range of all the password policies. 1044 * 1045 * <p> 1046 * 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 PasswordPolicyModelImpl}. 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. 1047 * </p> 1048 * 1049 * @param start the lower bound of the range of password policies 1050 * @param end the upper bound of the range of password policies (not inclusive) 1051 * @return the range of password policies 1052 */ 1053 public static List<PasswordPolicy> findAll(int start, int end) { 1054 return getPersistence().findAll(start, end); 1055 } 1056 1057 /** 1058 * Returns an ordered range of all the password policies. 1059 * 1060 * <p> 1061 * 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 PasswordPolicyModelImpl}. 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. 1062 * </p> 1063 * 1064 * @param start the lower bound of the range of password policies 1065 * @param end the upper bound of the range of password policies (not inclusive) 1066 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1067 * @return the ordered range of password policies 1068 */ 1069 public static List<PasswordPolicy> findAll(int start, int end, 1070 OrderByComparator<PasswordPolicy> orderByComparator) { 1071 return getPersistence().findAll(start, end, orderByComparator); 1072 } 1073 1074 /** 1075 * Returns an ordered range of all the password policies. 1076 * 1077 * <p> 1078 * 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 PasswordPolicyModelImpl}. 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. 1079 * </p> 1080 * 1081 * @param start the lower bound of the range of password policies 1082 * @param end the upper bound of the range of password policies (not inclusive) 1083 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1084 * @param retrieveFromCache whether to retrieve from the finder cache 1085 * @return the ordered range of password policies 1086 */ 1087 public static List<PasswordPolicy> findAll(int start, int end, 1088 OrderByComparator<PasswordPolicy> orderByComparator, 1089 boolean retrieveFromCache) { 1090 return getPersistence() 1091 .findAll(start, end, orderByComparator, retrieveFromCache); 1092 } 1093 1094 /** 1095 * Removes all the password policies from the database. 1096 */ 1097 public static void removeAll() { 1098 getPersistence().removeAll(); 1099 } 1100 1101 /** 1102 * Returns the number of password policies. 1103 * 1104 * @return the number of password policies 1105 */ 1106 public static int countAll() { 1107 return getPersistence().countAll(); 1108 } 1109 1110 public static java.util.Set<java.lang.String> getBadColumnNames() { 1111 return getPersistence().getBadColumnNames(); 1112 } 1113 1114 public static PasswordPolicyPersistence getPersistence() { 1115 if (_persistence == null) { 1116 _persistence = (PasswordPolicyPersistence)PortalBeanLocatorUtil.locate(PasswordPolicyPersistence.class.getName()); 1117 1118 ReferenceRegistry.registerReference(PasswordPolicyUtil.class, 1119 "_persistence"); 1120 } 1121 1122 return _persistence; 1123 } 1124 1125 private static PasswordPolicyPersistence _persistence; 1126 }