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