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 com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.model.PasswordPolicy; 023 import com.liferay.portal.service.ServiceContext; 024 025 import java.util.List; 026 027 /** 028 * 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. 029 * 030 * <p> 031 * Caching information and settings can be found in <code>portal.properties</code> 032 * </p> 033 * 034 * @author Brian Wing Shun Chan 035 * @see PasswordPolicyPersistence 036 * @see PasswordPolicyPersistenceImpl 037 * @generated 038 */ 039 public class PasswordPolicyUtil { 040 /* 041 * NOTE FOR DEVELOPERS: 042 * 043 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 044 */ 045 046 /** 047 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 048 */ 049 public static void clearCache() { 050 getPersistence().clearCache(); 051 } 052 053 /** 054 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 055 */ 056 public static void clearCache(PasswordPolicy passwordPolicy) { 057 getPersistence().clearCache(passwordPolicy); 058 } 059 060 /** 061 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 062 */ 063 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 064 throws SystemException { 065 return getPersistence().countWithDynamicQuery(dynamicQuery); 066 } 067 068 /** 069 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 070 */ 071 public static List<PasswordPolicy> findWithDynamicQuery( 072 DynamicQuery dynamicQuery) throws SystemException { 073 return getPersistence().findWithDynamicQuery(dynamicQuery); 074 } 075 076 /** 077 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 078 */ 079 public static List<PasswordPolicy> findWithDynamicQuery( 080 DynamicQuery dynamicQuery, int start, int end) 081 throws SystemException { 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 orderByComparator) throws SystemException { 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 throws SystemException { 101 return getPersistence().update(passwordPolicy); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static PasswordPolicy update(PasswordPolicy passwordPolicy, 108 ServiceContext serviceContext) throws SystemException { 109 return getPersistence().update(passwordPolicy, serviceContext); 110 } 111 112 /** 113 * Returns all the password policies where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching password policies 117 * @throws SystemException if a system exception occurred 118 */ 119 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid( 120 java.lang.String uuid) 121 throws com.liferay.portal.kernel.exception.SystemException { 122 return getPersistence().findByUuid(uuid); 123 } 124 125 /** 126 * Returns a range of all the password policies where uuid = ?. 127 * 128 * <p> 129 * 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. 130 * </p> 131 * 132 * @param uuid the uuid 133 * @param start the lower bound of the range of password policies 134 * @param end the upper bound of the range of password policies (not inclusive) 135 * @return the range of matching password policies 136 * @throws SystemException if a system exception occurred 137 */ 138 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid( 139 java.lang.String uuid, int start, int end) 140 throws com.liferay.portal.kernel.exception.SystemException { 141 return getPersistence().findByUuid(uuid, start, end); 142 } 143 144 /** 145 * Returns an ordered range of all the password policies where uuid = ?. 146 * 147 * <p> 148 * 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. 149 * </p> 150 * 151 * @param uuid the uuid 152 * @param start the lower bound of the range of password policies 153 * @param end the upper bound of the range of password policies (not inclusive) 154 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 155 * @return the ordered range of matching password policies 156 * @throws SystemException if a system exception occurred 157 */ 158 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid( 159 java.lang.String uuid, int start, int end, 160 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 161 throws com.liferay.portal.kernel.exception.SystemException { 162 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 163 } 164 165 /** 166 * Returns the first password policy in the ordered set where uuid = ?. 167 * 168 * @param uuid the uuid 169 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 170 * @return the first matching password policy 171 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 172 * @throws SystemException if a system exception occurred 173 */ 174 public static com.liferay.portal.model.PasswordPolicy findByUuid_First( 175 java.lang.String uuid, 176 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 177 throws com.liferay.portal.NoSuchPasswordPolicyException, 178 com.liferay.portal.kernel.exception.SystemException { 179 return getPersistence().findByUuid_First(uuid, orderByComparator); 180 } 181 182 /** 183 * Returns the first password policy in the ordered set where uuid = ?. 184 * 185 * @param uuid the uuid 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 188 * @throws SystemException if a system exception occurred 189 */ 190 public static com.liferay.portal.model.PasswordPolicy fetchByUuid_First( 191 java.lang.String uuid, 192 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 193 throws com.liferay.portal.kernel.exception.SystemException { 194 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 195 } 196 197 /** 198 * Returns the last password policy in the ordered set where uuid = ?. 199 * 200 * @param uuid the uuid 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the last matching password policy 203 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 204 * @throws SystemException if a system exception occurred 205 */ 206 public static com.liferay.portal.model.PasswordPolicy findByUuid_Last( 207 java.lang.String uuid, 208 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 209 throws com.liferay.portal.NoSuchPasswordPolicyException, 210 com.liferay.portal.kernel.exception.SystemException { 211 return getPersistence().findByUuid_Last(uuid, orderByComparator); 212 } 213 214 /** 215 * Returns the last password policy in the ordered set where uuid = ?. 216 * 217 * @param uuid the uuid 218 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 219 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 220 * @throws SystemException if a system exception occurred 221 */ 222 public static com.liferay.portal.model.PasswordPolicy fetchByUuid_Last( 223 java.lang.String uuid, 224 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 225 throws com.liferay.portal.kernel.exception.SystemException { 226 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 227 } 228 229 /** 230 * Returns the password policies before and after the current password policy in the ordered set where uuid = ?. 231 * 232 * @param passwordPolicyId the primary key of the current password policy 233 * @param uuid the uuid 234 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 235 * @return the previous, current, and next password policy 236 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 237 * @throws SystemException if a system exception occurred 238 */ 239 public static com.liferay.portal.model.PasswordPolicy[] findByUuid_PrevAndNext( 240 long passwordPolicyId, java.lang.String uuid, 241 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 242 throws com.liferay.portal.NoSuchPasswordPolicyException, 243 com.liferay.portal.kernel.exception.SystemException { 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 * @throws SystemException if a system exception occurred 255 */ 256 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid( 257 java.lang.String uuid) 258 throws com.liferay.portal.kernel.exception.SystemException { 259 return getPersistence().filterFindByUuid(uuid); 260 } 261 262 /** 263 * Returns a range of all the password policies that the user has permission to view where uuid = ?. 264 * 265 * <p> 266 * 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. 267 * </p> 268 * 269 * @param uuid the uuid 270 * @param start the lower bound of the range of password policies 271 * @param end the upper bound of the range of password policies (not inclusive) 272 * @return the range of matching password policies that the user has permission to view 273 * @throws SystemException if a system exception occurred 274 */ 275 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid( 276 java.lang.String uuid, int start, int end) 277 throws com.liferay.portal.kernel.exception.SystemException { 278 return getPersistence().filterFindByUuid(uuid, start, end); 279 } 280 281 /** 282 * Returns an ordered range of all the password policies that the user has permissions to view where uuid = ?. 283 * 284 * <p> 285 * 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. 286 * </p> 287 * 288 * @param uuid the uuid 289 * @param start the lower bound of the range of password policies 290 * @param end the upper bound of the range of password policies (not inclusive) 291 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 292 * @return the ordered range of matching password policies that the user has permission to view 293 * @throws SystemException if a system exception occurred 294 */ 295 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid( 296 java.lang.String uuid, int start, int end, 297 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 298 throws com.liferay.portal.kernel.exception.SystemException { 299 return getPersistence() 300 .filterFindByUuid(uuid, start, end, orderByComparator); 301 } 302 303 /** 304 * 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 = ?. 305 * 306 * @param passwordPolicyId the primary key of the current password policy 307 * @param uuid the uuid 308 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 309 * @return the previous, current, and next password policy 310 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 311 * @throws SystemException if a system exception occurred 312 */ 313 public static com.liferay.portal.model.PasswordPolicy[] filterFindByUuid_PrevAndNext( 314 long passwordPolicyId, java.lang.String uuid, 315 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 316 throws com.liferay.portal.NoSuchPasswordPolicyException, 317 com.liferay.portal.kernel.exception.SystemException { 318 return getPersistence() 319 .filterFindByUuid_PrevAndNext(passwordPolicyId, uuid, 320 orderByComparator); 321 } 322 323 /** 324 * Removes all the password policies where uuid = ? from the database. 325 * 326 * @param uuid the uuid 327 * @throws SystemException if a system exception occurred 328 */ 329 public static void removeByUuid(java.lang.String uuid) 330 throws com.liferay.portal.kernel.exception.SystemException { 331 getPersistence().removeByUuid(uuid); 332 } 333 334 /** 335 * Returns the number of password policies where uuid = ?. 336 * 337 * @param uuid the uuid 338 * @return the number of matching password policies 339 * @throws SystemException if a system exception occurred 340 */ 341 public static int countByUuid(java.lang.String uuid) 342 throws com.liferay.portal.kernel.exception.SystemException { 343 return getPersistence().countByUuid(uuid); 344 } 345 346 /** 347 * Returns the number of password policies that the user has permission to view where uuid = ?. 348 * 349 * @param uuid the uuid 350 * @return the number of matching password policies that the user has permission to view 351 * @throws SystemException if a system exception occurred 352 */ 353 public static int filterCountByUuid(java.lang.String uuid) 354 throws com.liferay.portal.kernel.exception.SystemException { 355 return getPersistence().filterCountByUuid(uuid); 356 } 357 358 /** 359 * Returns all the password policies where uuid = ? and companyId = ?. 360 * 361 * @param uuid the uuid 362 * @param companyId the company ID 363 * @return the matching password policies 364 * @throws SystemException if a system exception occurred 365 */ 366 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid_C( 367 java.lang.String uuid, long companyId) 368 throws com.liferay.portal.kernel.exception.SystemException { 369 return getPersistence().findByUuid_C(uuid, companyId); 370 } 371 372 /** 373 * Returns a 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 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. 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 * @return the range of matching password policies 384 * @throws SystemException if a system exception occurred 385 */ 386 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid_C( 387 java.lang.String uuid, long companyId, int start, int end) 388 throws com.liferay.portal.kernel.exception.SystemException { 389 return getPersistence().findByUuid_C(uuid, companyId, start, end); 390 } 391 392 /** 393 * Returns an ordered range of all the password policies where uuid = ? and companyId = ?. 394 * 395 * <p> 396 * 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. 397 * </p> 398 * 399 * @param uuid the uuid 400 * @param companyId the company ID 401 * @param start the lower bound of the range of password policies 402 * @param end the upper bound of the range of password policies (not inclusive) 403 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 404 * @return the ordered range of matching password policies 405 * @throws SystemException if a system exception occurred 406 */ 407 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid_C( 408 java.lang.String uuid, long companyId, int start, int end, 409 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 410 throws com.liferay.portal.kernel.exception.SystemException { 411 return getPersistence() 412 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 413 } 414 415 /** 416 * Returns the first password policy in the ordered set where uuid = ? and companyId = ?. 417 * 418 * @param uuid the uuid 419 * @param companyId the company ID 420 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 421 * @return the first matching password policy 422 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 423 * @throws SystemException if a system exception occurred 424 */ 425 public static com.liferay.portal.model.PasswordPolicy findByUuid_C_First( 426 java.lang.String uuid, long companyId, 427 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 428 throws com.liferay.portal.NoSuchPasswordPolicyException, 429 com.liferay.portal.kernel.exception.SystemException { 430 return getPersistence() 431 .findByUuid_C_First(uuid, companyId, orderByComparator); 432 } 433 434 /** 435 * Returns the first password policy in the ordered set where uuid = ? and companyId = ?. 436 * 437 * @param uuid the uuid 438 * @param companyId the company ID 439 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 440 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 441 * @throws SystemException if a system exception occurred 442 */ 443 public static com.liferay.portal.model.PasswordPolicy fetchByUuid_C_First( 444 java.lang.String uuid, long companyId, 445 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 446 throws com.liferay.portal.kernel.exception.SystemException { 447 return getPersistence() 448 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 449 } 450 451 /** 452 * Returns the last password policy in the ordered set where uuid = ? and companyId = ?. 453 * 454 * @param uuid the uuid 455 * @param companyId the company ID 456 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 457 * @return the last matching password policy 458 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 459 * @throws SystemException if a system exception occurred 460 */ 461 public static com.liferay.portal.model.PasswordPolicy findByUuid_C_Last( 462 java.lang.String uuid, long companyId, 463 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 464 throws com.liferay.portal.NoSuchPasswordPolicyException, 465 com.liferay.portal.kernel.exception.SystemException { 466 return getPersistence() 467 .findByUuid_C_Last(uuid, companyId, orderByComparator); 468 } 469 470 /** 471 * Returns the last password policy in the ordered set where uuid = ? and companyId = ?. 472 * 473 * @param uuid the uuid 474 * @param companyId the company ID 475 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 476 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 477 * @throws SystemException if a system exception occurred 478 */ 479 public static com.liferay.portal.model.PasswordPolicy fetchByUuid_C_Last( 480 java.lang.String uuid, long companyId, 481 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 482 throws com.liferay.portal.kernel.exception.SystemException { 483 return getPersistence() 484 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 485 } 486 487 /** 488 * Returns the password policies before and after the current password policy in the ordered set where uuid = ? and companyId = ?. 489 * 490 * @param passwordPolicyId the primary key of the current password policy 491 * @param uuid the uuid 492 * @param companyId the company ID 493 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 494 * @return the previous, current, and next password policy 495 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 496 * @throws SystemException if a system exception occurred 497 */ 498 public static com.liferay.portal.model.PasswordPolicy[] findByUuid_C_PrevAndNext( 499 long passwordPolicyId, java.lang.String uuid, long companyId, 500 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 501 throws com.liferay.portal.NoSuchPasswordPolicyException, 502 com.liferay.portal.kernel.exception.SystemException { 503 return getPersistence() 504 .findByUuid_C_PrevAndNext(passwordPolicyId, uuid, companyId, 505 orderByComparator); 506 } 507 508 /** 509 * Returns all the password policies that the user has permission to view where uuid = ? and companyId = ?. 510 * 511 * @param uuid the uuid 512 * @param companyId the company ID 513 * @return the matching password policies that the user has permission to view 514 * @throws SystemException if a system exception occurred 515 */ 516 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid_C( 517 java.lang.String uuid, long companyId) 518 throws com.liferay.portal.kernel.exception.SystemException { 519 return getPersistence().filterFindByUuid_C(uuid, companyId); 520 } 521 522 /** 523 * Returns a range of all the password policies that the user has permission to view where uuid = ? and companyId = ?. 524 * 525 * <p> 526 * 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. 527 * </p> 528 * 529 * @param uuid the uuid 530 * @param companyId the company ID 531 * @param start the lower bound of the range of password policies 532 * @param end the upper bound of the range of password policies (not inclusive) 533 * @return the range of matching password policies that the user has permission to view 534 * @throws SystemException if a system exception occurred 535 */ 536 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid_C( 537 java.lang.String uuid, long companyId, int start, int end) 538 throws com.liferay.portal.kernel.exception.SystemException { 539 return getPersistence().filterFindByUuid_C(uuid, companyId, start, end); 540 } 541 542 /** 543 * Returns an ordered range of all the password policies that the user has permissions to view where uuid = ? and companyId = ?. 544 * 545 * <p> 546 * 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. 547 * </p> 548 * 549 * @param uuid the uuid 550 * @param companyId the company ID 551 * @param start the lower bound of the range of password policies 552 * @param end the upper bound of the range of password policies (not inclusive) 553 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 554 * @return the ordered range of matching password policies that the user has permission to view 555 * @throws SystemException if a system exception occurred 556 */ 557 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid_C( 558 java.lang.String uuid, long companyId, int start, int end, 559 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 560 throws com.liferay.portal.kernel.exception.SystemException { 561 return getPersistence() 562 .filterFindByUuid_C(uuid, companyId, start, end, 563 orderByComparator); 564 } 565 566 /** 567 * 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 = ?. 568 * 569 * @param passwordPolicyId the primary key of the current password policy 570 * @param uuid the uuid 571 * @param companyId the company ID 572 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 573 * @return the previous, current, and next password policy 574 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 575 * @throws SystemException if a system exception occurred 576 */ 577 public static com.liferay.portal.model.PasswordPolicy[] filterFindByUuid_C_PrevAndNext( 578 long passwordPolicyId, java.lang.String uuid, long companyId, 579 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 580 throws com.liferay.portal.NoSuchPasswordPolicyException, 581 com.liferay.portal.kernel.exception.SystemException { 582 return getPersistence() 583 .filterFindByUuid_C_PrevAndNext(passwordPolicyId, uuid, 584 companyId, orderByComparator); 585 } 586 587 /** 588 * Removes all the password policies where uuid = ? and companyId = ? from the database. 589 * 590 * @param uuid the uuid 591 * @param companyId the company ID 592 * @throws SystemException if a system exception occurred 593 */ 594 public static void removeByUuid_C(java.lang.String uuid, long companyId) 595 throws com.liferay.portal.kernel.exception.SystemException { 596 getPersistence().removeByUuid_C(uuid, companyId); 597 } 598 599 /** 600 * Returns the number of password policies where uuid = ? and companyId = ?. 601 * 602 * @param uuid the uuid 603 * @param companyId the company ID 604 * @return the number of matching password policies 605 * @throws SystemException if a system exception occurred 606 */ 607 public static int countByUuid_C(java.lang.String uuid, long companyId) 608 throws com.liferay.portal.kernel.exception.SystemException { 609 return getPersistence().countByUuid_C(uuid, companyId); 610 } 611 612 /** 613 * Returns the number of password policies that the user has permission to view where uuid = ? and companyId = ?. 614 * 615 * @param uuid the uuid 616 * @param companyId the company ID 617 * @return the number of matching password policies that the user has permission to view 618 * @throws SystemException if a system exception occurred 619 */ 620 public static int filterCountByUuid_C(java.lang.String uuid, long companyId) 621 throws com.liferay.portal.kernel.exception.SystemException { 622 return getPersistence().filterCountByUuid_C(uuid, companyId); 623 } 624 625 /** 626 * Returns the password policy where companyId = ? and defaultPolicy = ? or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found. 627 * 628 * @param companyId the company ID 629 * @param defaultPolicy the default policy 630 * @return the matching password policy 631 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 632 * @throws SystemException if a system exception occurred 633 */ 634 public static com.liferay.portal.model.PasswordPolicy findByC_DP( 635 long companyId, boolean defaultPolicy) 636 throws com.liferay.portal.NoSuchPasswordPolicyException, 637 com.liferay.portal.kernel.exception.SystemException { 638 return getPersistence().findByC_DP(companyId, defaultPolicy); 639 } 640 641 /** 642 * Returns the password policy where companyId = ? and defaultPolicy = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 643 * 644 * @param companyId the company ID 645 * @param defaultPolicy the default policy 646 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 647 * @throws SystemException if a system exception occurred 648 */ 649 public static com.liferay.portal.model.PasswordPolicy fetchByC_DP( 650 long companyId, boolean defaultPolicy) 651 throws com.liferay.portal.kernel.exception.SystemException { 652 return getPersistence().fetchByC_DP(companyId, defaultPolicy); 653 } 654 655 /** 656 * Returns the password policy where companyId = ? and defaultPolicy = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 657 * 658 * @param companyId the company ID 659 * @param defaultPolicy the default policy 660 * @param retrieveFromCache whether to use the finder cache 661 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 662 * @throws SystemException if a system exception occurred 663 */ 664 public static com.liferay.portal.model.PasswordPolicy fetchByC_DP( 665 long companyId, boolean defaultPolicy, boolean retrieveFromCache) 666 throws com.liferay.portal.kernel.exception.SystemException { 667 return getPersistence() 668 .fetchByC_DP(companyId, defaultPolicy, retrieveFromCache); 669 } 670 671 /** 672 * Removes the password policy where companyId = ? and defaultPolicy = ? from the database. 673 * 674 * @param companyId the company ID 675 * @param defaultPolicy the default policy 676 * @return the password policy that was removed 677 * @throws SystemException if a system exception occurred 678 */ 679 public static com.liferay.portal.model.PasswordPolicy removeByC_DP( 680 long companyId, boolean defaultPolicy) 681 throws com.liferay.portal.NoSuchPasswordPolicyException, 682 com.liferay.portal.kernel.exception.SystemException { 683 return getPersistence().removeByC_DP(companyId, defaultPolicy); 684 } 685 686 /** 687 * Returns the number of password policies where companyId = ? and defaultPolicy = ?. 688 * 689 * @param companyId the company ID 690 * @param defaultPolicy the default policy 691 * @return the number of matching password policies 692 * @throws SystemException if a system exception occurred 693 */ 694 public static int countByC_DP(long companyId, boolean defaultPolicy) 695 throws com.liferay.portal.kernel.exception.SystemException { 696 return getPersistence().countByC_DP(companyId, defaultPolicy); 697 } 698 699 /** 700 * Returns the password policy where companyId = ? and name = ? or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found. 701 * 702 * @param companyId the company ID 703 * @param name the name 704 * @return the matching password policy 705 * @throws com.liferay.portal.NoSuchPasswordPolicyException 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 findByC_N( 709 long companyId, java.lang.String name) 710 throws com.liferay.portal.NoSuchPasswordPolicyException, 711 com.liferay.portal.kernel.exception.SystemException { 712 return getPersistence().findByC_N(companyId, name); 713 } 714 715 /** 716 * Returns the password policy where companyId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 717 * 718 * @param companyId the company ID 719 * @param name the name 720 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 721 * @throws SystemException if a system exception occurred 722 */ 723 public static com.liferay.portal.model.PasswordPolicy fetchByC_N( 724 long companyId, java.lang.String name) 725 throws com.liferay.portal.kernel.exception.SystemException { 726 return getPersistence().fetchByC_N(companyId, name); 727 } 728 729 /** 730 * Returns the password policy where companyId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 731 * 732 * @param companyId the company ID 733 * @param name the name 734 * @param retrieveFromCache whether to use the finder cache 735 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 736 * @throws SystemException if a system exception occurred 737 */ 738 public static com.liferay.portal.model.PasswordPolicy fetchByC_N( 739 long companyId, java.lang.String name, boolean retrieveFromCache) 740 throws com.liferay.portal.kernel.exception.SystemException { 741 return getPersistence().fetchByC_N(companyId, name, retrieveFromCache); 742 } 743 744 /** 745 * Removes the password policy where companyId = ? and name = ? from the database. 746 * 747 * @param companyId the company ID 748 * @param name the name 749 * @return the password policy that was removed 750 * @throws SystemException if a system exception occurred 751 */ 752 public static com.liferay.portal.model.PasswordPolicy removeByC_N( 753 long companyId, java.lang.String name) 754 throws com.liferay.portal.NoSuchPasswordPolicyException, 755 com.liferay.portal.kernel.exception.SystemException { 756 return getPersistence().removeByC_N(companyId, name); 757 } 758 759 /** 760 * Returns the number of password policies where companyId = ? and name = ?. 761 * 762 * @param companyId the company ID 763 * @param name the name 764 * @return the number of matching password policies 765 * @throws SystemException if a system exception occurred 766 */ 767 public static int countByC_N(long companyId, java.lang.String name) 768 throws com.liferay.portal.kernel.exception.SystemException { 769 return getPersistence().countByC_N(companyId, name); 770 } 771 772 /** 773 * Caches the password policy in the entity cache if it is enabled. 774 * 775 * @param passwordPolicy the password policy 776 */ 777 public static void cacheResult( 778 com.liferay.portal.model.PasswordPolicy passwordPolicy) { 779 getPersistence().cacheResult(passwordPolicy); 780 } 781 782 /** 783 * Caches the password policies in the entity cache if it is enabled. 784 * 785 * @param passwordPolicies the password policies 786 */ 787 public static void cacheResult( 788 java.util.List<com.liferay.portal.model.PasswordPolicy> passwordPolicies) { 789 getPersistence().cacheResult(passwordPolicies); 790 } 791 792 /** 793 * Creates a new password policy with the primary key. Does not add the password policy to the database. 794 * 795 * @param passwordPolicyId the primary key for the new password policy 796 * @return the new password policy 797 */ 798 public static com.liferay.portal.model.PasswordPolicy create( 799 long passwordPolicyId) { 800 return getPersistence().create(passwordPolicyId); 801 } 802 803 /** 804 * Removes the password policy with the primary key from the database. Also notifies the appropriate model listeners. 805 * 806 * @param passwordPolicyId the primary key of the password policy 807 * @return the password policy that was removed 808 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 809 * @throws SystemException if a system exception occurred 810 */ 811 public static com.liferay.portal.model.PasswordPolicy remove( 812 long passwordPolicyId) 813 throws com.liferay.portal.NoSuchPasswordPolicyException, 814 com.liferay.portal.kernel.exception.SystemException { 815 return getPersistence().remove(passwordPolicyId); 816 } 817 818 public static com.liferay.portal.model.PasswordPolicy updateImpl( 819 com.liferay.portal.model.PasswordPolicy passwordPolicy) 820 throws com.liferay.portal.kernel.exception.SystemException { 821 return getPersistence().updateImpl(passwordPolicy); 822 } 823 824 /** 825 * Returns the password policy with the primary key or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found. 826 * 827 * @param passwordPolicyId the primary key of the password policy 828 * @return the password policy 829 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 830 * @throws SystemException if a system exception occurred 831 */ 832 public static com.liferay.portal.model.PasswordPolicy findByPrimaryKey( 833 long passwordPolicyId) 834 throws com.liferay.portal.NoSuchPasswordPolicyException, 835 com.liferay.portal.kernel.exception.SystemException { 836 return getPersistence().findByPrimaryKey(passwordPolicyId); 837 } 838 839 /** 840 * Returns the password policy with the primary key or returns <code>null</code> if it could not be found. 841 * 842 * @param passwordPolicyId the primary key of the password policy 843 * @return the password policy, or <code>null</code> if a password policy with the primary key could not be found 844 * @throws SystemException if a system exception occurred 845 */ 846 public static com.liferay.portal.model.PasswordPolicy fetchByPrimaryKey( 847 long passwordPolicyId) 848 throws com.liferay.portal.kernel.exception.SystemException { 849 return getPersistence().fetchByPrimaryKey(passwordPolicyId); 850 } 851 852 /** 853 * Returns all the password policies. 854 * 855 * @return the password policies 856 * @throws SystemException if a system exception occurred 857 */ 858 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll() 859 throws com.liferay.portal.kernel.exception.SystemException { 860 return getPersistence().findAll(); 861 } 862 863 /** 864 * Returns a range of all the password policies. 865 * 866 * <p> 867 * 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. 868 * </p> 869 * 870 * @param start the lower bound of the range of password policies 871 * @param end the upper bound of the range of password policies (not inclusive) 872 * @return the range of password policies 873 * @throws SystemException if a system exception occurred 874 */ 875 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll( 876 int start, int end) 877 throws com.liferay.portal.kernel.exception.SystemException { 878 return getPersistence().findAll(start, end); 879 } 880 881 /** 882 * Returns an ordered range of all the password policies. 883 * 884 * <p> 885 * 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. 886 * </p> 887 * 888 * @param start the lower bound of the range of password policies 889 * @param end the upper bound of the range of password policies (not inclusive) 890 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 891 * @return the ordered range of password policies 892 * @throws SystemException if a system exception occurred 893 */ 894 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll( 895 int start, int end, 896 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 897 throws com.liferay.portal.kernel.exception.SystemException { 898 return getPersistence().findAll(start, end, orderByComparator); 899 } 900 901 /** 902 * Removes all the password policies from the database. 903 * 904 * @throws SystemException if a system exception occurred 905 */ 906 public static void removeAll() 907 throws com.liferay.portal.kernel.exception.SystemException { 908 getPersistence().removeAll(); 909 } 910 911 /** 912 * Returns the number of password policies. 913 * 914 * @return the number of password policies 915 * @throws SystemException if a system exception occurred 916 */ 917 public static int countAll() 918 throws com.liferay.portal.kernel.exception.SystemException { 919 return getPersistence().countAll(); 920 } 921 922 public static PasswordPolicyPersistence getPersistence() { 923 if (_persistence == null) { 924 _persistence = (PasswordPolicyPersistence)PortalBeanLocatorUtil.locate(PasswordPolicyPersistence.class.getName()); 925 926 ReferenceRegistry.registerReference(PasswordPolicyUtil.class, 927 "_persistence"); 928 } 929 930 return _persistence; 931 } 932 933 /** 934 * @deprecated As of 6.2.0 935 */ 936 public void setPersistence(PasswordPolicyPersistence persistence) { 937 } 938 939 private static PasswordPolicyPersistence _persistence; 940 }