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 all the password policies where companyId = ?. 627 * 628 * @param companyId the company ID 629 * @return the matching password policies 630 * @throws SystemException if a system exception occurred 631 */ 632 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByCompanyId( 633 long companyId) 634 throws com.liferay.portal.kernel.exception.SystemException { 635 return getPersistence().findByCompanyId(companyId); 636 } 637 638 /** 639 * Returns a range of all the password policies where companyId = ?. 640 * 641 * <p> 642 * 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. 643 * </p> 644 * 645 * @param companyId the company ID 646 * @param start the lower bound of the range of password policies 647 * @param end the upper bound of the range of password policies (not inclusive) 648 * @return the range of matching password policies 649 * @throws SystemException if a system exception occurred 650 */ 651 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByCompanyId( 652 long companyId, int start, int end) 653 throws com.liferay.portal.kernel.exception.SystemException { 654 return getPersistence().findByCompanyId(companyId, start, end); 655 } 656 657 /** 658 * Returns an ordered range of all the password policies where companyId = ?. 659 * 660 * <p> 661 * 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. 662 * </p> 663 * 664 * @param companyId the company ID 665 * @param start the lower bound of the range of password policies 666 * @param end the upper bound of the range of password policies (not inclusive) 667 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 668 * @return the ordered range of matching password policies 669 * @throws SystemException if a system exception occurred 670 */ 671 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByCompanyId( 672 long companyId, int start, int end, 673 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 674 throws com.liferay.portal.kernel.exception.SystemException { 675 return getPersistence() 676 .findByCompanyId(companyId, start, end, orderByComparator); 677 } 678 679 /** 680 * Returns the first password policy in the ordered set where companyId = ?. 681 * 682 * @param companyId the company ID 683 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 684 * @return the first matching password policy 685 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 686 * @throws SystemException if a system exception occurred 687 */ 688 public static com.liferay.portal.model.PasswordPolicy findByCompanyId_First( 689 long companyId, 690 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 691 throws com.liferay.portal.NoSuchPasswordPolicyException, 692 com.liferay.portal.kernel.exception.SystemException { 693 return getPersistence() 694 .findByCompanyId_First(companyId, orderByComparator); 695 } 696 697 /** 698 * Returns the first password policy in the ordered set where companyId = ?. 699 * 700 * @param companyId the company ID 701 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 702 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 703 * @throws SystemException if a system exception occurred 704 */ 705 public static com.liferay.portal.model.PasswordPolicy fetchByCompanyId_First( 706 long companyId, 707 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 708 throws com.liferay.portal.kernel.exception.SystemException { 709 return getPersistence() 710 .fetchByCompanyId_First(companyId, orderByComparator); 711 } 712 713 /** 714 * Returns the last password policy in the ordered set where companyId = ?. 715 * 716 * @param companyId the company ID 717 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 718 * @return the last matching password policy 719 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 720 * @throws SystemException if a system exception occurred 721 */ 722 public static com.liferay.portal.model.PasswordPolicy findByCompanyId_Last( 723 long companyId, 724 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 725 throws com.liferay.portal.NoSuchPasswordPolicyException, 726 com.liferay.portal.kernel.exception.SystemException { 727 return getPersistence() 728 .findByCompanyId_Last(companyId, orderByComparator); 729 } 730 731 /** 732 * Returns the last password policy in the ordered set where companyId = ?. 733 * 734 * @param companyId the company ID 735 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 736 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 737 * @throws SystemException if a system exception occurred 738 */ 739 public static com.liferay.portal.model.PasswordPolicy fetchByCompanyId_Last( 740 long companyId, 741 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 742 throws com.liferay.portal.kernel.exception.SystemException { 743 return getPersistence() 744 .fetchByCompanyId_Last(companyId, orderByComparator); 745 } 746 747 /** 748 * Returns the password policies before and after the current password policy in the ordered set where companyId = ?. 749 * 750 * @param passwordPolicyId the primary key of the current password policy 751 * @param companyId the company ID 752 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 753 * @return the previous, current, and next password policy 754 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 755 * @throws SystemException if a system exception occurred 756 */ 757 public static com.liferay.portal.model.PasswordPolicy[] findByCompanyId_PrevAndNext( 758 long passwordPolicyId, long companyId, 759 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 760 throws com.liferay.portal.NoSuchPasswordPolicyException, 761 com.liferay.portal.kernel.exception.SystemException { 762 return getPersistence() 763 .findByCompanyId_PrevAndNext(passwordPolicyId, companyId, 764 orderByComparator); 765 } 766 767 /** 768 * Returns all the password policies that the user has permission to view where companyId = ?. 769 * 770 * @param companyId the company ID 771 * @return the matching password policies that the user has permission to view 772 * @throws SystemException if a system exception occurred 773 */ 774 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByCompanyId( 775 long companyId) 776 throws com.liferay.portal.kernel.exception.SystemException { 777 return getPersistence().filterFindByCompanyId(companyId); 778 } 779 780 /** 781 * Returns a range of all the password policies that the user has permission to view where companyId = ?. 782 * 783 * <p> 784 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 785 * </p> 786 * 787 * @param companyId the company ID 788 * @param start the lower bound of the range of password policies 789 * @param end the upper bound of the range of password policies (not inclusive) 790 * @return the range of matching password policies that the user has permission to view 791 * @throws SystemException if a system exception occurred 792 */ 793 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByCompanyId( 794 long companyId, int start, int end) 795 throws com.liferay.portal.kernel.exception.SystemException { 796 return getPersistence().filterFindByCompanyId(companyId, start, end); 797 } 798 799 /** 800 * Returns an ordered range of all the password policies that the user has permissions to view where companyId = ?. 801 * 802 * <p> 803 * 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. 804 * </p> 805 * 806 * @param companyId the company ID 807 * @param start the lower bound of the range of password policies 808 * @param end the upper bound of the range of password policies (not inclusive) 809 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 810 * @return the ordered range of matching password policies that the user has permission to view 811 * @throws SystemException if a system exception occurred 812 */ 813 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByCompanyId( 814 long companyId, int start, int end, 815 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 816 throws com.liferay.portal.kernel.exception.SystemException { 817 return getPersistence() 818 .filterFindByCompanyId(companyId, start, end, 819 orderByComparator); 820 } 821 822 /** 823 * 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 = ?. 824 * 825 * @param passwordPolicyId the primary key of the current password policy 826 * @param companyId the company ID 827 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 828 * @return the previous, current, and next 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[] filterFindByCompanyId_PrevAndNext( 833 long passwordPolicyId, long companyId, 834 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 835 throws com.liferay.portal.NoSuchPasswordPolicyException, 836 com.liferay.portal.kernel.exception.SystemException { 837 return getPersistence() 838 .filterFindByCompanyId_PrevAndNext(passwordPolicyId, 839 companyId, orderByComparator); 840 } 841 842 /** 843 * Removes all the password policies where companyId = ? from the database. 844 * 845 * @param companyId the company ID 846 * @throws SystemException if a system exception occurred 847 */ 848 public static void removeByCompanyId(long companyId) 849 throws com.liferay.portal.kernel.exception.SystemException { 850 getPersistence().removeByCompanyId(companyId); 851 } 852 853 /** 854 * Returns the number of password policies where companyId = ?. 855 * 856 * @param companyId the company ID 857 * @return the number of matching password policies 858 * @throws SystemException if a system exception occurred 859 */ 860 public static int countByCompanyId(long companyId) 861 throws com.liferay.portal.kernel.exception.SystemException { 862 return getPersistence().countByCompanyId(companyId); 863 } 864 865 /** 866 * Returns the number of password policies that the user has permission to view where companyId = ?. 867 * 868 * @param companyId the company ID 869 * @return the number of matching password policies that the user has permission to view 870 * @throws SystemException if a system exception occurred 871 */ 872 public static int filterCountByCompanyId(long companyId) 873 throws com.liferay.portal.kernel.exception.SystemException { 874 return getPersistence().filterCountByCompanyId(companyId); 875 } 876 877 /** 878 * Returns the password policy where companyId = ? and defaultPolicy = ? or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found. 879 * 880 * @param companyId the company ID 881 * @param defaultPolicy the default policy 882 * @return the matching password policy 883 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 884 * @throws SystemException if a system exception occurred 885 */ 886 public static com.liferay.portal.model.PasswordPolicy findByC_DP( 887 long companyId, boolean defaultPolicy) 888 throws com.liferay.portal.NoSuchPasswordPolicyException, 889 com.liferay.portal.kernel.exception.SystemException { 890 return getPersistence().findByC_DP(companyId, defaultPolicy); 891 } 892 893 /** 894 * Returns the password policy where companyId = ? and defaultPolicy = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 895 * 896 * @param companyId the company ID 897 * @param defaultPolicy the default policy 898 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 899 * @throws SystemException if a system exception occurred 900 */ 901 public static com.liferay.portal.model.PasswordPolicy fetchByC_DP( 902 long companyId, boolean defaultPolicy) 903 throws com.liferay.portal.kernel.exception.SystemException { 904 return getPersistence().fetchByC_DP(companyId, defaultPolicy); 905 } 906 907 /** 908 * Returns the password policy where companyId = ? and defaultPolicy = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 909 * 910 * @param companyId the company ID 911 * @param defaultPolicy the default policy 912 * @param retrieveFromCache whether to use the finder cache 913 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 914 * @throws SystemException if a system exception occurred 915 */ 916 public static com.liferay.portal.model.PasswordPolicy fetchByC_DP( 917 long companyId, boolean defaultPolicy, boolean retrieveFromCache) 918 throws com.liferay.portal.kernel.exception.SystemException { 919 return getPersistence() 920 .fetchByC_DP(companyId, defaultPolicy, retrieveFromCache); 921 } 922 923 /** 924 * Removes the password policy where companyId = ? and defaultPolicy = ? from the database. 925 * 926 * @param companyId the company ID 927 * @param defaultPolicy the default policy 928 * @return the password policy that was removed 929 * @throws SystemException if a system exception occurred 930 */ 931 public static com.liferay.portal.model.PasswordPolicy removeByC_DP( 932 long companyId, boolean defaultPolicy) 933 throws com.liferay.portal.NoSuchPasswordPolicyException, 934 com.liferay.portal.kernel.exception.SystemException { 935 return getPersistence().removeByC_DP(companyId, defaultPolicy); 936 } 937 938 /** 939 * Returns the number of password policies where companyId = ? and defaultPolicy = ?. 940 * 941 * @param companyId the company ID 942 * @param defaultPolicy the default policy 943 * @return the number of matching password policies 944 * @throws SystemException if a system exception occurred 945 */ 946 public static int countByC_DP(long companyId, boolean defaultPolicy) 947 throws com.liferay.portal.kernel.exception.SystemException { 948 return getPersistence().countByC_DP(companyId, defaultPolicy); 949 } 950 951 /** 952 * Returns the password policy where companyId = ? and name = ? or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found. 953 * 954 * @param companyId the company ID 955 * @param name the name 956 * @return the matching password policy 957 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 958 * @throws SystemException if a system exception occurred 959 */ 960 public static com.liferay.portal.model.PasswordPolicy findByC_N( 961 long companyId, java.lang.String name) 962 throws com.liferay.portal.NoSuchPasswordPolicyException, 963 com.liferay.portal.kernel.exception.SystemException { 964 return getPersistence().findByC_N(companyId, name); 965 } 966 967 /** 968 * Returns the password policy where companyId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 969 * 970 * @param companyId the company ID 971 * @param name the name 972 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 973 * @throws SystemException if a system exception occurred 974 */ 975 public static com.liferay.portal.model.PasswordPolicy fetchByC_N( 976 long companyId, java.lang.String name) 977 throws com.liferay.portal.kernel.exception.SystemException { 978 return getPersistence().fetchByC_N(companyId, name); 979 } 980 981 /** 982 * Returns the password policy where companyId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 983 * 984 * @param companyId the company ID 985 * @param name the name 986 * @param retrieveFromCache whether to use the finder cache 987 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 988 * @throws SystemException if a system exception occurred 989 */ 990 public static com.liferay.portal.model.PasswordPolicy fetchByC_N( 991 long companyId, java.lang.String name, boolean retrieveFromCache) 992 throws com.liferay.portal.kernel.exception.SystemException { 993 return getPersistence().fetchByC_N(companyId, name, retrieveFromCache); 994 } 995 996 /** 997 * Removes the password policy where companyId = ? and name = ? from the database. 998 * 999 * @param companyId the company ID 1000 * @param name the name 1001 * @return the password policy that was removed 1002 * @throws SystemException if a system exception occurred 1003 */ 1004 public static com.liferay.portal.model.PasswordPolicy removeByC_N( 1005 long companyId, java.lang.String name) 1006 throws com.liferay.portal.NoSuchPasswordPolicyException, 1007 com.liferay.portal.kernel.exception.SystemException { 1008 return getPersistence().removeByC_N(companyId, name); 1009 } 1010 1011 /** 1012 * Returns the number of password policies where companyId = ? and name = ?. 1013 * 1014 * @param companyId the company ID 1015 * @param name the name 1016 * @return the number of matching password policies 1017 * @throws SystemException if a system exception occurred 1018 */ 1019 public static int countByC_N(long companyId, java.lang.String name) 1020 throws com.liferay.portal.kernel.exception.SystemException { 1021 return getPersistence().countByC_N(companyId, name); 1022 } 1023 1024 /** 1025 * Caches the password policy in the entity cache if it is enabled. 1026 * 1027 * @param passwordPolicy the password policy 1028 */ 1029 public static void cacheResult( 1030 com.liferay.portal.model.PasswordPolicy passwordPolicy) { 1031 getPersistence().cacheResult(passwordPolicy); 1032 } 1033 1034 /** 1035 * Caches the password policies in the entity cache if it is enabled. 1036 * 1037 * @param passwordPolicies the password policies 1038 */ 1039 public static void cacheResult( 1040 java.util.List<com.liferay.portal.model.PasswordPolicy> passwordPolicies) { 1041 getPersistence().cacheResult(passwordPolicies); 1042 } 1043 1044 /** 1045 * Creates a new password policy with the primary key. Does not add the password policy to the database. 1046 * 1047 * @param passwordPolicyId the primary key for the new password policy 1048 * @return the new password policy 1049 */ 1050 public static com.liferay.portal.model.PasswordPolicy create( 1051 long passwordPolicyId) { 1052 return getPersistence().create(passwordPolicyId); 1053 } 1054 1055 /** 1056 * Removes the password policy with the primary key from the database. Also notifies the appropriate model listeners. 1057 * 1058 * @param passwordPolicyId the primary key of the password policy 1059 * @return the password policy that was removed 1060 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 1061 * @throws SystemException if a system exception occurred 1062 */ 1063 public static com.liferay.portal.model.PasswordPolicy remove( 1064 long passwordPolicyId) 1065 throws com.liferay.portal.NoSuchPasswordPolicyException, 1066 com.liferay.portal.kernel.exception.SystemException { 1067 return getPersistence().remove(passwordPolicyId); 1068 } 1069 1070 public static com.liferay.portal.model.PasswordPolicy updateImpl( 1071 com.liferay.portal.model.PasswordPolicy passwordPolicy) 1072 throws com.liferay.portal.kernel.exception.SystemException { 1073 return getPersistence().updateImpl(passwordPolicy); 1074 } 1075 1076 /** 1077 * Returns the password policy with the primary key or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found. 1078 * 1079 * @param passwordPolicyId the primary key of the password policy 1080 * @return the password policy 1081 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 1082 * @throws SystemException if a system exception occurred 1083 */ 1084 public static com.liferay.portal.model.PasswordPolicy findByPrimaryKey( 1085 long passwordPolicyId) 1086 throws com.liferay.portal.NoSuchPasswordPolicyException, 1087 com.liferay.portal.kernel.exception.SystemException { 1088 return getPersistence().findByPrimaryKey(passwordPolicyId); 1089 } 1090 1091 /** 1092 * Returns the password policy with the primary key or returns <code>null</code> if it could not be found. 1093 * 1094 * @param passwordPolicyId the primary key of the password policy 1095 * @return the password policy, or <code>null</code> if a password policy with the primary key could not be found 1096 * @throws SystemException if a system exception occurred 1097 */ 1098 public static com.liferay.portal.model.PasswordPolicy fetchByPrimaryKey( 1099 long passwordPolicyId) 1100 throws com.liferay.portal.kernel.exception.SystemException { 1101 return getPersistence().fetchByPrimaryKey(passwordPolicyId); 1102 } 1103 1104 /** 1105 * Returns all the password policies. 1106 * 1107 * @return the password policies 1108 * @throws SystemException if a system exception occurred 1109 */ 1110 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll() 1111 throws com.liferay.portal.kernel.exception.SystemException { 1112 return getPersistence().findAll(); 1113 } 1114 1115 /** 1116 * Returns a range of all the password policies. 1117 * 1118 * <p> 1119 * 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. 1120 * </p> 1121 * 1122 * @param start the lower bound of the range of password policies 1123 * @param end the upper bound of the range of password policies (not inclusive) 1124 * @return the range of password policies 1125 * @throws SystemException if a system exception occurred 1126 */ 1127 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll( 1128 int start, int end) 1129 throws com.liferay.portal.kernel.exception.SystemException { 1130 return getPersistence().findAll(start, end); 1131 } 1132 1133 /** 1134 * Returns an ordered range of all the password policies. 1135 * 1136 * <p> 1137 * 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. 1138 * </p> 1139 * 1140 * @param start the lower bound of the range of password policies 1141 * @param end the upper bound of the range of password policies (not inclusive) 1142 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1143 * @return the ordered range of password policies 1144 * @throws SystemException if a system exception occurred 1145 */ 1146 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll( 1147 int start, int end, 1148 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1149 throws com.liferay.portal.kernel.exception.SystemException { 1150 return getPersistence().findAll(start, end, orderByComparator); 1151 } 1152 1153 /** 1154 * Removes all the password policies from the database. 1155 * 1156 * @throws SystemException if a system exception occurred 1157 */ 1158 public static void removeAll() 1159 throws com.liferay.portal.kernel.exception.SystemException { 1160 getPersistence().removeAll(); 1161 } 1162 1163 /** 1164 * Returns the number of password policies. 1165 * 1166 * @return the number of password policies 1167 * @throws SystemException if a system exception occurred 1168 */ 1169 public static int countAll() 1170 throws com.liferay.portal.kernel.exception.SystemException { 1171 return getPersistence().countAll(); 1172 } 1173 1174 public static PasswordPolicyPersistence getPersistence() { 1175 if (_persistence == null) { 1176 _persistence = (PasswordPolicyPersistence)PortalBeanLocatorUtil.locate(PasswordPolicyPersistence.class.getName()); 1177 1178 ReferenceRegistry.registerReference(PasswordPolicyUtil.class, 1179 "_persistence"); 1180 } 1181 1182 return _persistence; 1183 } 1184 1185 /** 1186 * @deprecated As of 6.2.0 1187 */ 1188 public void setPersistence(PasswordPolicyPersistence persistence) { 1189 } 1190 1191 private static PasswordPolicyPersistence _persistence; 1192 }