001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.kernel.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.exception.NoSuchPasswordPolicyException; 020 import com.liferay.portal.kernel.model.PasswordPolicy; 021 022 /** 023 * The persistence interface for the password policy service. 024 * 025 * <p> 026 * Caching information and settings can be found in <code>portal.properties</code> 027 * </p> 028 * 029 * @author Brian Wing Shun Chan 030 * @see com.liferay.portal.service.persistence.impl.PasswordPolicyPersistenceImpl 031 * @see PasswordPolicyUtil 032 * @generated 033 */ 034 @ProviderType 035 public interface PasswordPolicyPersistence extends BasePersistence<PasswordPolicy> { 036 /* 037 * NOTE FOR DEVELOPERS: 038 * 039 * Never modify or reference this interface directly. Always use {@link PasswordPolicyUtil} to access the password policy persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 040 */ 041 042 /** 043 * Returns all the password policies where uuid = ?. 044 * 045 * @param uuid the uuid 046 * @return the matching password policies 047 */ 048 public java.util.List<PasswordPolicy> findByUuid(java.lang.String uuid); 049 050 /** 051 * Returns a range of all the password policies where uuid = ?. 052 * 053 * <p> 054 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 055 * </p> 056 * 057 * @param uuid the uuid 058 * @param start the lower bound of the range of password policies 059 * @param end the upper bound of the range of password policies (not inclusive) 060 * @return the range of matching password policies 061 */ 062 public java.util.List<PasswordPolicy> findByUuid(java.lang.String uuid, 063 int start, int end); 064 065 /** 066 * Returns an ordered range of all the password policies where uuid = ?. 067 * 068 * <p> 069 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 070 * </p> 071 * 072 * @param uuid the uuid 073 * @param start the lower bound of the range of password policies 074 * @param end the upper bound of the range of password policies (not inclusive) 075 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 076 * @return the ordered range of matching password policies 077 */ 078 public java.util.List<PasswordPolicy> findByUuid(java.lang.String uuid, 079 int start, int end, 080 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 081 082 /** 083 * Returns an ordered range of all the password policies where uuid = ?. 084 * 085 * <p> 086 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 087 * </p> 088 * 089 * @param uuid the uuid 090 * @param start the lower bound of the range of password policies 091 * @param end the upper bound of the range of password policies (not inclusive) 092 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 093 * @param retrieveFromCache whether to retrieve from the finder cache 094 * @return the ordered range of matching password policies 095 */ 096 public java.util.List<PasswordPolicy> findByUuid(java.lang.String uuid, 097 int start, int end, 098 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator, 099 boolean retrieveFromCache); 100 101 /** 102 * Returns the first password policy in the ordered set where uuid = ?. 103 * 104 * @param uuid the uuid 105 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 106 * @return the first matching password policy 107 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 108 */ 109 public PasswordPolicy findByUuid_First(java.lang.String uuid, 110 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 111 throws NoSuchPasswordPolicyException; 112 113 /** 114 * Returns the first password policy in the ordered set where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 118 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 119 */ 120 public PasswordPolicy fetchByUuid_First(java.lang.String uuid, 121 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 122 123 /** 124 * Returns the last password policy in the ordered set where uuid = ?. 125 * 126 * @param uuid the uuid 127 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 128 * @return the last matching password policy 129 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 130 */ 131 public PasswordPolicy findByUuid_Last(java.lang.String uuid, 132 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 133 throws NoSuchPasswordPolicyException; 134 135 /** 136 * Returns the last password policy in the ordered set where uuid = ?. 137 * 138 * @param uuid the uuid 139 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 140 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 141 */ 142 public PasswordPolicy fetchByUuid_Last(java.lang.String uuid, 143 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 144 145 /** 146 * Returns the password policies before and after the current password policy in the ordered set where uuid = ?. 147 * 148 * @param passwordPolicyId the primary key of the current password policy 149 * @param uuid the uuid 150 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 151 * @return the previous, current, and next password policy 152 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 153 */ 154 public PasswordPolicy[] findByUuid_PrevAndNext(long passwordPolicyId, 155 java.lang.String uuid, 156 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 157 throws NoSuchPasswordPolicyException; 158 159 /** 160 * Returns all the password policies that the user has permission to view where uuid = ?. 161 * 162 * @param uuid the uuid 163 * @return the matching password policies that the user has permission to view 164 */ 165 public java.util.List<PasswordPolicy> filterFindByUuid( 166 java.lang.String uuid); 167 168 /** 169 * Returns a range of all the password policies that the user has permission to view where uuid = ?. 170 * 171 * <p> 172 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 173 * </p> 174 * 175 * @param uuid the uuid 176 * @param start the lower bound of the range of password policies 177 * @param end the upper bound of the range of password policies (not inclusive) 178 * @return the range of matching password policies that the user has permission to view 179 */ 180 public java.util.List<PasswordPolicy> filterFindByUuid( 181 java.lang.String uuid, int start, int end); 182 183 /** 184 * Returns an ordered range of all the password policies that the user has permissions to view where uuid = ?. 185 * 186 * <p> 187 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 188 * </p> 189 * 190 * @param uuid the uuid 191 * @param start the lower bound of the range of password policies 192 * @param end the upper bound of the range of password policies (not inclusive) 193 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 194 * @return the ordered range of matching password policies that the user has permission to view 195 */ 196 public java.util.List<PasswordPolicy> filterFindByUuid( 197 java.lang.String uuid, int start, int end, 198 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 199 200 /** 201 * 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 = ?. 202 * 203 * @param passwordPolicyId the primary key of the current password policy 204 * @param uuid the uuid 205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 206 * @return the previous, current, and next password policy 207 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 208 */ 209 public PasswordPolicy[] filterFindByUuid_PrevAndNext( 210 long passwordPolicyId, java.lang.String uuid, 211 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 212 throws NoSuchPasswordPolicyException; 213 214 /** 215 * Removes all the password policies where uuid = ? from the database. 216 * 217 * @param uuid the uuid 218 */ 219 public void removeByUuid(java.lang.String uuid); 220 221 /** 222 * Returns the number of password policies where uuid = ?. 223 * 224 * @param uuid the uuid 225 * @return the number of matching password policies 226 */ 227 public int countByUuid(java.lang.String uuid); 228 229 /** 230 * Returns the number of password policies that the user has permission to view where uuid = ?. 231 * 232 * @param uuid the uuid 233 * @return the number of matching password policies that the user has permission to view 234 */ 235 public int filterCountByUuid(java.lang.String uuid); 236 237 /** 238 * Returns all the password policies where uuid = ? and companyId = ?. 239 * 240 * @param uuid the uuid 241 * @param companyId the company ID 242 * @return the matching password policies 243 */ 244 public java.util.List<PasswordPolicy> findByUuid_C(java.lang.String uuid, 245 long companyId); 246 247 /** 248 * Returns a range of all the password policies where uuid = ? and companyId = ?. 249 * 250 * <p> 251 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 252 * </p> 253 * 254 * @param uuid the uuid 255 * @param companyId the company ID 256 * @param start the lower bound of the range of password policies 257 * @param end the upper bound of the range of password policies (not inclusive) 258 * @return the range of matching password policies 259 */ 260 public java.util.List<PasswordPolicy> findByUuid_C(java.lang.String uuid, 261 long companyId, int start, int end); 262 263 /** 264 * Returns an ordered range of all the password policies where uuid = ? and companyId = ?. 265 * 266 * <p> 267 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 268 * </p> 269 * 270 * @param uuid the uuid 271 * @param companyId the company ID 272 * @param start the lower bound of the range of password policies 273 * @param end the upper bound of the range of password policies (not inclusive) 274 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 275 * @return the ordered range of matching password policies 276 */ 277 public java.util.List<PasswordPolicy> findByUuid_C(java.lang.String uuid, 278 long companyId, int start, int end, 279 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 280 281 /** 282 * Returns an ordered range of all the password policies where uuid = ? and companyId = ?. 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 286 * </p> 287 * 288 * @param uuid the uuid 289 * @param companyId the company ID 290 * @param start the lower bound of the range of password policies 291 * @param end the upper bound of the range of password policies (not inclusive) 292 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 293 * @param retrieveFromCache whether to retrieve from the finder cache 294 * @return the ordered range of matching password policies 295 */ 296 public java.util.List<PasswordPolicy> findByUuid_C(java.lang.String uuid, 297 long companyId, int start, int end, 298 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator, 299 boolean retrieveFromCache); 300 301 /** 302 * Returns the first password policy in the ordered set where uuid = ? and companyId = ?. 303 * 304 * @param uuid the uuid 305 * @param companyId the company ID 306 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 307 * @return the first matching password policy 308 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 309 */ 310 public PasswordPolicy findByUuid_C_First(java.lang.String uuid, 311 long companyId, 312 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 313 throws NoSuchPasswordPolicyException; 314 315 /** 316 * Returns the first password policy in the ordered set where uuid = ? and companyId = ?. 317 * 318 * @param uuid the uuid 319 * @param companyId the company ID 320 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 321 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 322 */ 323 public PasswordPolicy fetchByUuid_C_First(java.lang.String uuid, 324 long companyId, 325 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 326 327 /** 328 * Returns the last password policy in the ordered set where uuid = ? and companyId = ?. 329 * 330 * @param uuid the uuid 331 * @param companyId the company ID 332 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 333 * @return the last matching password policy 334 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 335 */ 336 public PasswordPolicy findByUuid_C_Last(java.lang.String uuid, 337 long companyId, 338 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 339 throws NoSuchPasswordPolicyException; 340 341 /** 342 * Returns the last password policy in the ordered set where uuid = ? and companyId = ?. 343 * 344 * @param uuid the uuid 345 * @param companyId the company ID 346 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 347 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 348 */ 349 public PasswordPolicy fetchByUuid_C_Last(java.lang.String uuid, 350 long companyId, 351 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 352 353 /** 354 * Returns the password policies before and after the current password policy in the ordered set where uuid = ? and companyId = ?. 355 * 356 * @param passwordPolicyId the primary key of the current password policy 357 * @param uuid the uuid 358 * @param companyId the company ID 359 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 360 * @return the previous, current, and next password policy 361 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 362 */ 363 public PasswordPolicy[] findByUuid_C_PrevAndNext(long passwordPolicyId, 364 java.lang.String uuid, long companyId, 365 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 366 throws NoSuchPasswordPolicyException; 367 368 /** 369 * Returns all the password policies that the user has permission to view where uuid = ? and companyId = ?. 370 * 371 * @param uuid the uuid 372 * @param companyId the company ID 373 * @return the matching password policies that the user has permission to view 374 */ 375 public java.util.List<PasswordPolicy> filterFindByUuid_C( 376 java.lang.String uuid, long companyId); 377 378 /** 379 * Returns a range of all the password policies that the user has permission to view where uuid = ? and companyId = ?. 380 * 381 * <p> 382 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 383 * </p> 384 * 385 * @param uuid the uuid 386 * @param companyId the company ID 387 * @param start the lower bound of the range of password policies 388 * @param end the upper bound of the range of password policies (not inclusive) 389 * @return the range of matching password policies that the user has permission to view 390 */ 391 public java.util.List<PasswordPolicy> filterFindByUuid_C( 392 java.lang.String uuid, long companyId, int start, int end); 393 394 /** 395 * Returns an ordered range of all the password policies that the user has permissions to view where uuid = ? and companyId = ?. 396 * 397 * <p> 398 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 399 * </p> 400 * 401 * @param uuid the uuid 402 * @param companyId the company ID 403 * @param start the lower bound of the range of password policies 404 * @param end the upper bound of the range of password policies (not inclusive) 405 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 406 * @return the ordered range of matching password policies that the user has permission to view 407 */ 408 public java.util.List<PasswordPolicy> filterFindByUuid_C( 409 java.lang.String uuid, long companyId, int start, int end, 410 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 411 412 /** 413 * 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 = ?. 414 * 415 * @param passwordPolicyId the primary key of the current password policy 416 * @param uuid the uuid 417 * @param companyId the company ID 418 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 419 * @return the previous, current, and next password policy 420 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 421 */ 422 public PasswordPolicy[] filterFindByUuid_C_PrevAndNext( 423 long passwordPolicyId, java.lang.String uuid, long companyId, 424 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 425 throws NoSuchPasswordPolicyException; 426 427 /** 428 * Removes all the password policies where uuid = ? and companyId = ? from the database. 429 * 430 * @param uuid the uuid 431 * @param companyId the company ID 432 */ 433 public void removeByUuid_C(java.lang.String uuid, long companyId); 434 435 /** 436 * Returns the number of password policies where uuid = ? and companyId = ?. 437 * 438 * @param uuid the uuid 439 * @param companyId the company ID 440 * @return the number of matching password policies 441 */ 442 public int countByUuid_C(java.lang.String uuid, long companyId); 443 444 /** 445 * Returns the number of password policies that the user has permission to view where uuid = ? and companyId = ?. 446 * 447 * @param uuid the uuid 448 * @param companyId the company ID 449 * @return the number of matching password policies that the user has permission to view 450 */ 451 public int filterCountByUuid_C(java.lang.String uuid, long companyId); 452 453 /** 454 * Returns all the password policies where companyId = ?. 455 * 456 * @param companyId the company ID 457 * @return the matching password policies 458 */ 459 public java.util.List<PasswordPolicy> findByCompanyId(long companyId); 460 461 /** 462 * Returns a range of all the password policies where companyId = ?. 463 * 464 * <p> 465 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 466 * </p> 467 * 468 * @param companyId the company ID 469 * @param start the lower bound of the range of password policies 470 * @param end the upper bound of the range of password policies (not inclusive) 471 * @return the range of matching password policies 472 */ 473 public java.util.List<PasswordPolicy> findByCompanyId(long companyId, 474 int start, int end); 475 476 /** 477 * Returns an ordered range of all the password policies where companyId = ?. 478 * 479 * <p> 480 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 481 * </p> 482 * 483 * @param companyId the company ID 484 * @param start the lower bound of the range of password policies 485 * @param end the upper bound of the range of password policies (not inclusive) 486 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 487 * @return the ordered range of matching password policies 488 */ 489 public java.util.List<PasswordPolicy> findByCompanyId(long companyId, 490 int start, int end, 491 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 492 493 /** 494 * Returns an ordered range of all the password policies where companyId = ?. 495 * 496 * <p> 497 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 498 * </p> 499 * 500 * @param companyId the company ID 501 * @param start the lower bound of the range of password policies 502 * @param end the upper bound of the range of password policies (not inclusive) 503 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 504 * @param retrieveFromCache whether to retrieve from the finder cache 505 * @return the ordered range of matching password policies 506 */ 507 public java.util.List<PasswordPolicy> findByCompanyId(long companyId, 508 int start, int end, 509 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator, 510 boolean retrieveFromCache); 511 512 /** 513 * Returns the first password policy in the ordered set where companyId = ?. 514 * 515 * @param companyId the company ID 516 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 517 * @return the first matching password policy 518 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 519 */ 520 public PasswordPolicy findByCompanyId_First(long companyId, 521 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 522 throws NoSuchPasswordPolicyException; 523 524 /** 525 * Returns the first password policy in the ordered set where companyId = ?. 526 * 527 * @param companyId the company ID 528 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 529 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 530 */ 531 public PasswordPolicy fetchByCompanyId_First(long companyId, 532 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 533 534 /** 535 * Returns the last password policy in the ordered set where companyId = ?. 536 * 537 * @param companyId the company ID 538 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 539 * @return the last matching password policy 540 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 541 */ 542 public PasswordPolicy findByCompanyId_Last(long companyId, 543 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 544 throws NoSuchPasswordPolicyException; 545 546 /** 547 * Returns the last password policy in the ordered set where companyId = ?. 548 * 549 * @param companyId the company ID 550 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 551 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 552 */ 553 public PasswordPolicy fetchByCompanyId_Last(long companyId, 554 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 555 556 /** 557 * Returns the password policies before and after the current password policy in the ordered set where companyId = ?. 558 * 559 * @param passwordPolicyId the primary key of the current password policy 560 * @param companyId the company ID 561 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 562 * @return the previous, current, and next password policy 563 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 564 */ 565 public PasswordPolicy[] findByCompanyId_PrevAndNext(long passwordPolicyId, 566 long companyId, 567 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 568 throws NoSuchPasswordPolicyException; 569 570 /** 571 * Returns all the password policies that the user has permission to view where companyId = ?. 572 * 573 * @param companyId the company ID 574 * @return the matching password policies that the user has permission to view 575 */ 576 public java.util.List<PasswordPolicy> filterFindByCompanyId(long companyId); 577 578 /** 579 * Returns a range of all the password policies that the user has permission to view where companyId = ?. 580 * 581 * <p> 582 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 583 * </p> 584 * 585 * @param companyId the company ID 586 * @param start the lower bound of the range of password policies 587 * @param end the upper bound of the range of password policies (not inclusive) 588 * @return the range of matching password policies that the user has permission to view 589 */ 590 public java.util.List<PasswordPolicy> filterFindByCompanyId( 591 long companyId, int start, int end); 592 593 /** 594 * Returns an ordered range of all the password policies that the user has permissions to view where companyId = ?. 595 * 596 * <p> 597 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 598 * </p> 599 * 600 * @param companyId the company ID 601 * @param start the lower bound of the range of password policies 602 * @param end the upper bound of the range of password policies (not inclusive) 603 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 604 * @return the ordered range of matching password policies that the user has permission to view 605 */ 606 public java.util.List<PasswordPolicy> filterFindByCompanyId( 607 long companyId, int start, int end, 608 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 609 610 /** 611 * 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 = ?. 612 * 613 * @param passwordPolicyId the primary key of the current password policy 614 * @param companyId the company ID 615 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 616 * @return the previous, current, and next password policy 617 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 618 */ 619 public PasswordPolicy[] filterFindByCompanyId_PrevAndNext( 620 long passwordPolicyId, long companyId, 621 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator) 622 throws NoSuchPasswordPolicyException; 623 624 /** 625 * Removes all the password policies where companyId = ? from the database. 626 * 627 * @param companyId the company ID 628 */ 629 public void removeByCompanyId(long companyId); 630 631 /** 632 * Returns the number of password policies where companyId = ?. 633 * 634 * @param companyId the company ID 635 * @return the number of matching password policies 636 */ 637 public int countByCompanyId(long companyId); 638 639 /** 640 * Returns the number of password policies that the user has permission to view where companyId = ?. 641 * 642 * @param companyId the company ID 643 * @return the number of matching password policies that the user has permission to view 644 */ 645 public int filterCountByCompanyId(long companyId); 646 647 /** 648 * Returns the password policy where companyId = ? and defaultPolicy = ? or throws a {@link NoSuchPasswordPolicyException} if it could not be found. 649 * 650 * @param companyId the company ID 651 * @param defaultPolicy the default policy 652 * @return the matching password policy 653 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 654 */ 655 public PasswordPolicy findByC_DP(long companyId, boolean defaultPolicy) 656 throws NoSuchPasswordPolicyException; 657 658 /** 659 * Returns the password policy where companyId = ? and defaultPolicy = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 660 * 661 * @param companyId the company ID 662 * @param defaultPolicy the default policy 663 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 664 */ 665 public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy); 666 667 /** 668 * Returns the password policy where companyId = ? and defaultPolicy = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 669 * 670 * @param companyId the company ID 671 * @param defaultPolicy the default policy 672 * @param retrieveFromCache whether to retrieve from the finder cache 673 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 674 */ 675 public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy, 676 boolean retrieveFromCache); 677 678 /** 679 * Removes the password policy where companyId = ? and defaultPolicy = ? from the database. 680 * 681 * @param companyId the company ID 682 * @param defaultPolicy the default policy 683 * @return the password policy that was removed 684 */ 685 public PasswordPolicy removeByC_DP(long companyId, boolean defaultPolicy) 686 throws NoSuchPasswordPolicyException; 687 688 /** 689 * Returns the number of password policies where companyId = ? and defaultPolicy = ?. 690 * 691 * @param companyId the company ID 692 * @param defaultPolicy the default policy 693 * @return the number of matching password policies 694 */ 695 public int countByC_DP(long companyId, boolean defaultPolicy); 696 697 /** 698 * Returns the password policy where companyId = ? and name = ? or throws a {@link NoSuchPasswordPolicyException} if it could not be found. 699 * 700 * @param companyId the company ID 701 * @param name the name 702 * @return the matching password policy 703 * @throws NoSuchPasswordPolicyException if a matching password policy could not be found 704 */ 705 public PasswordPolicy findByC_N(long companyId, java.lang.String name) 706 throws NoSuchPasswordPolicyException; 707 708 /** 709 * Returns the password policy where companyId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 710 * 711 * @param companyId the company ID 712 * @param name the name 713 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 714 */ 715 public PasswordPolicy fetchByC_N(long companyId, java.lang.String name); 716 717 /** 718 * Returns the password policy where companyId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 719 * 720 * @param companyId the company ID 721 * @param name the name 722 * @param retrieveFromCache whether to retrieve from the finder cache 723 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 724 */ 725 public PasswordPolicy fetchByC_N(long companyId, java.lang.String name, 726 boolean retrieveFromCache); 727 728 /** 729 * Removes the password policy where companyId = ? and name = ? from the database. 730 * 731 * @param companyId the company ID 732 * @param name the name 733 * @return the password policy that was removed 734 */ 735 public PasswordPolicy removeByC_N(long companyId, java.lang.String name) 736 throws NoSuchPasswordPolicyException; 737 738 /** 739 * Returns the number of password policies where companyId = ? and name = ?. 740 * 741 * @param companyId the company ID 742 * @param name the name 743 * @return the number of matching password policies 744 */ 745 public int countByC_N(long companyId, java.lang.String name); 746 747 /** 748 * Caches the password policy in the entity cache if it is enabled. 749 * 750 * @param passwordPolicy the password policy 751 */ 752 public void cacheResult(PasswordPolicy passwordPolicy); 753 754 /** 755 * Caches the password policies in the entity cache if it is enabled. 756 * 757 * @param passwordPolicies the password policies 758 */ 759 public void cacheResult(java.util.List<PasswordPolicy> passwordPolicies); 760 761 /** 762 * Creates a new password policy with the primary key. Does not add the password policy to the database. 763 * 764 * @param passwordPolicyId the primary key for the new password policy 765 * @return the new password policy 766 */ 767 public PasswordPolicy create(long passwordPolicyId); 768 769 /** 770 * Removes the password policy with the primary key from the database. Also notifies the appropriate model listeners. 771 * 772 * @param passwordPolicyId the primary key of the password policy 773 * @return the password policy that was removed 774 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 775 */ 776 public PasswordPolicy remove(long passwordPolicyId) 777 throws NoSuchPasswordPolicyException; 778 779 public PasswordPolicy updateImpl(PasswordPolicy passwordPolicy); 780 781 /** 782 * Returns the password policy with the primary key or throws a {@link NoSuchPasswordPolicyException} if it could not be found. 783 * 784 * @param passwordPolicyId the primary key of the password policy 785 * @return the password policy 786 * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found 787 */ 788 public PasswordPolicy findByPrimaryKey(long passwordPolicyId) 789 throws NoSuchPasswordPolicyException; 790 791 /** 792 * Returns the password policy with the primary key or returns <code>null</code> if it could not be found. 793 * 794 * @param passwordPolicyId the primary key of the password policy 795 * @return the password policy, or <code>null</code> if a password policy with the primary key could not be found 796 */ 797 public PasswordPolicy fetchByPrimaryKey(long passwordPolicyId); 798 799 @Override 800 public java.util.Map<java.io.Serializable, PasswordPolicy> fetchByPrimaryKeys( 801 java.util.Set<java.io.Serializable> primaryKeys); 802 803 /** 804 * Returns all the password policies. 805 * 806 * @return the password policies 807 */ 808 public java.util.List<PasswordPolicy> findAll(); 809 810 /** 811 * Returns a range of all the password policies. 812 * 813 * <p> 814 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 815 * </p> 816 * 817 * @param start the lower bound of the range of password policies 818 * @param end the upper bound of the range of password policies (not inclusive) 819 * @return the range of password policies 820 */ 821 public java.util.List<PasswordPolicy> findAll(int start, int end); 822 823 /** 824 * Returns an ordered range of all the password policies. 825 * 826 * <p> 827 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 828 * </p> 829 * 830 * @param start the lower bound of the range of password policies 831 * @param end the upper bound of the range of password policies (not inclusive) 832 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 833 * @return the ordered range of password policies 834 */ 835 public java.util.List<PasswordPolicy> findAll(int start, int end, 836 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator); 837 838 /** 839 * Returns an ordered range of all the password policies. 840 * 841 * <p> 842 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 843 * </p> 844 * 845 * @param start the lower bound of the range of password policies 846 * @param end the upper bound of the range of password policies (not inclusive) 847 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 848 * @param retrieveFromCache whether to retrieve from the finder cache 849 * @return the ordered range of password policies 850 */ 851 public java.util.List<PasswordPolicy> findAll(int start, int end, 852 com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator, 853 boolean retrieveFromCache); 854 855 /** 856 * Removes all the password policies from the database. 857 */ 858 public void removeAll(); 859 860 /** 861 * Returns the number of password policies. 862 * 863 * @return the number of password policies 864 */ 865 public int countAll(); 866 867 @Override 868 public java.util.Set<java.lang.String> getBadColumnNames(); 869 }