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