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.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.UserTracker; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the user tracker service. This utility wraps {@link com.liferay.portal.service.persistence.impl.UserTrackerPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see UserTrackerPersistence 037 * @see com.liferay.portal.service.persistence.impl.UserTrackerPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class UserTrackerUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(UserTracker userTracker) { 059 getPersistence().clearCache(userTracker); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<UserTracker> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<UserTracker> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<UserTracker> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<UserTracker> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static UserTracker update(UserTracker userTracker) { 100 return getPersistence().update(userTracker); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static UserTracker update(UserTracker userTracker, 107 ServiceContext serviceContext) { 108 return getPersistence().update(userTracker, serviceContext); 109 } 110 111 /** 112 * Returns all the user trackers where companyId = ?. 113 * 114 * @param companyId the company ID 115 * @return the matching user trackers 116 */ 117 public static List<UserTracker> findByCompanyId(long companyId) { 118 return getPersistence().findByCompanyId(companyId); 119 } 120 121 /** 122 * Returns a range of all the user trackers where companyId = ?. 123 * 124 * <p> 125 * 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 UserTrackerModelImpl}. 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. 126 * </p> 127 * 128 * @param companyId the company ID 129 * @param start the lower bound of the range of user trackers 130 * @param end the upper bound of the range of user trackers (not inclusive) 131 * @return the range of matching user trackers 132 */ 133 public static List<UserTracker> findByCompanyId(long companyId, int start, 134 int end) { 135 return getPersistence().findByCompanyId(companyId, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the user trackers where companyId = ?. 140 * 141 * <p> 142 * 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 UserTrackerModelImpl}. 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. 143 * </p> 144 * 145 * @param companyId the company ID 146 * @param start the lower bound of the range of user trackers 147 * @param end the upper bound of the range of user trackers (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching user trackers 150 */ 151 public static List<UserTracker> findByCompanyId(long companyId, int start, 152 int end, OrderByComparator<UserTracker> orderByComparator) { 153 return getPersistence() 154 .findByCompanyId(companyId, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns the first user tracker in the ordered set where companyId = ?. 159 * 160 * @param companyId the company ID 161 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 162 * @return the first matching user tracker 163 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 164 */ 165 public static UserTracker findByCompanyId_First(long companyId, 166 OrderByComparator<UserTracker> orderByComparator) 167 throws com.liferay.portal.NoSuchUserTrackerException { 168 return getPersistence() 169 .findByCompanyId_First(companyId, orderByComparator); 170 } 171 172 /** 173 * Returns the first user tracker in the ordered set where companyId = ?. 174 * 175 * @param companyId the company ID 176 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 177 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 178 */ 179 public static UserTracker fetchByCompanyId_First(long companyId, 180 OrderByComparator<UserTracker> orderByComparator) { 181 return getPersistence() 182 .fetchByCompanyId_First(companyId, orderByComparator); 183 } 184 185 /** 186 * Returns the last user tracker in the ordered set where companyId = ?. 187 * 188 * @param companyId the company ID 189 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 190 * @return the last matching user tracker 191 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 192 */ 193 public static UserTracker findByCompanyId_Last(long companyId, 194 OrderByComparator<UserTracker> orderByComparator) 195 throws com.liferay.portal.NoSuchUserTrackerException { 196 return getPersistence() 197 .findByCompanyId_Last(companyId, orderByComparator); 198 } 199 200 /** 201 * Returns the last user tracker in the ordered set where companyId = ?. 202 * 203 * @param companyId the company ID 204 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 205 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 206 */ 207 public static UserTracker fetchByCompanyId_Last(long companyId, 208 OrderByComparator<UserTracker> orderByComparator) { 209 return getPersistence() 210 .fetchByCompanyId_Last(companyId, orderByComparator); 211 } 212 213 /** 214 * Returns the user trackers before and after the current user tracker in the ordered set where companyId = ?. 215 * 216 * @param userTrackerId the primary key of the current user tracker 217 * @param companyId the company ID 218 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 219 * @return the previous, current, and next user tracker 220 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 221 */ 222 public static UserTracker[] findByCompanyId_PrevAndNext( 223 long userTrackerId, long companyId, 224 OrderByComparator<UserTracker> orderByComparator) 225 throws com.liferay.portal.NoSuchUserTrackerException { 226 return getPersistence() 227 .findByCompanyId_PrevAndNext(userTrackerId, companyId, 228 orderByComparator); 229 } 230 231 /** 232 * Removes all the user trackers where companyId = ? from the database. 233 * 234 * @param companyId the company ID 235 */ 236 public static void removeByCompanyId(long companyId) { 237 getPersistence().removeByCompanyId(companyId); 238 } 239 240 /** 241 * Returns the number of user trackers where companyId = ?. 242 * 243 * @param companyId the company ID 244 * @return the number of matching user trackers 245 */ 246 public static int countByCompanyId(long companyId) { 247 return getPersistence().countByCompanyId(companyId); 248 } 249 250 /** 251 * Returns all the user trackers where userId = ?. 252 * 253 * @param userId the user ID 254 * @return the matching user trackers 255 */ 256 public static List<UserTracker> findByUserId(long userId) { 257 return getPersistence().findByUserId(userId); 258 } 259 260 /** 261 * Returns a range of all the user trackers where userId = ?. 262 * 263 * <p> 264 * 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 UserTrackerModelImpl}. 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. 265 * </p> 266 * 267 * @param userId the user ID 268 * @param start the lower bound of the range of user trackers 269 * @param end the upper bound of the range of user trackers (not inclusive) 270 * @return the range of matching user trackers 271 */ 272 public static List<UserTracker> findByUserId(long userId, int start, int end) { 273 return getPersistence().findByUserId(userId, start, end); 274 } 275 276 /** 277 * Returns an ordered range of all the user trackers where userId = ?. 278 * 279 * <p> 280 * 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 UserTrackerModelImpl}. 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. 281 * </p> 282 * 283 * @param userId the user ID 284 * @param start the lower bound of the range of user trackers 285 * @param end the upper bound of the range of user trackers (not inclusive) 286 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 287 * @return the ordered range of matching user trackers 288 */ 289 public static List<UserTracker> findByUserId(long userId, int start, 290 int end, OrderByComparator<UserTracker> orderByComparator) { 291 return getPersistence() 292 .findByUserId(userId, start, end, orderByComparator); 293 } 294 295 /** 296 * Returns the first user tracker in the ordered set where userId = ?. 297 * 298 * @param userId the user ID 299 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 300 * @return the first matching user tracker 301 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 302 */ 303 public static UserTracker findByUserId_First(long userId, 304 OrderByComparator<UserTracker> orderByComparator) 305 throws com.liferay.portal.NoSuchUserTrackerException { 306 return getPersistence().findByUserId_First(userId, orderByComparator); 307 } 308 309 /** 310 * Returns the first user tracker in the ordered set where userId = ?. 311 * 312 * @param userId the user ID 313 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 314 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 315 */ 316 public static UserTracker fetchByUserId_First(long userId, 317 OrderByComparator<UserTracker> orderByComparator) { 318 return getPersistence().fetchByUserId_First(userId, orderByComparator); 319 } 320 321 /** 322 * Returns the last user tracker in the ordered set where userId = ?. 323 * 324 * @param userId the user ID 325 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 326 * @return the last matching user tracker 327 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 328 */ 329 public static UserTracker findByUserId_Last(long userId, 330 OrderByComparator<UserTracker> orderByComparator) 331 throws com.liferay.portal.NoSuchUserTrackerException { 332 return getPersistence().findByUserId_Last(userId, orderByComparator); 333 } 334 335 /** 336 * Returns the last user tracker in the ordered set where userId = ?. 337 * 338 * @param userId the user ID 339 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 340 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 341 */ 342 public static UserTracker fetchByUserId_Last(long userId, 343 OrderByComparator<UserTracker> orderByComparator) { 344 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 345 } 346 347 /** 348 * Returns the user trackers before and after the current user tracker in the ordered set where userId = ?. 349 * 350 * @param userTrackerId the primary key of the current user tracker 351 * @param userId the user ID 352 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 353 * @return the previous, current, and next user tracker 354 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 355 */ 356 public static UserTracker[] findByUserId_PrevAndNext(long userTrackerId, 357 long userId, OrderByComparator<UserTracker> orderByComparator) 358 throws com.liferay.portal.NoSuchUserTrackerException { 359 return getPersistence() 360 .findByUserId_PrevAndNext(userTrackerId, userId, 361 orderByComparator); 362 } 363 364 /** 365 * Removes all the user trackers where userId = ? from the database. 366 * 367 * @param userId the user ID 368 */ 369 public static void removeByUserId(long userId) { 370 getPersistence().removeByUserId(userId); 371 } 372 373 /** 374 * Returns the number of user trackers where userId = ?. 375 * 376 * @param userId the user ID 377 * @return the number of matching user trackers 378 */ 379 public static int countByUserId(long userId) { 380 return getPersistence().countByUserId(userId); 381 } 382 383 /** 384 * Returns all the user trackers where sessionId = ?. 385 * 386 * @param sessionId the session ID 387 * @return the matching user trackers 388 */ 389 public static List<UserTracker> findBySessionId(java.lang.String sessionId) { 390 return getPersistence().findBySessionId(sessionId); 391 } 392 393 /** 394 * Returns a range of all the user trackers where sessionId = ?. 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 UserTrackerModelImpl}. 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 sessionId the session ID 401 * @param start the lower bound of the range of user trackers 402 * @param end the upper bound of the range of user trackers (not inclusive) 403 * @return the range of matching user trackers 404 */ 405 public static List<UserTracker> findBySessionId( 406 java.lang.String sessionId, int start, int end) { 407 return getPersistence().findBySessionId(sessionId, start, end); 408 } 409 410 /** 411 * Returns an ordered range of all the user trackers where sessionId = ?. 412 * 413 * <p> 414 * 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 UserTrackerModelImpl}. 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. 415 * </p> 416 * 417 * @param sessionId the session ID 418 * @param start the lower bound of the range of user trackers 419 * @param end the upper bound of the range of user trackers (not inclusive) 420 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 421 * @return the ordered range of matching user trackers 422 */ 423 public static List<UserTracker> findBySessionId( 424 java.lang.String sessionId, int start, int end, 425 OrderByComparator<UserTracker> orderByComparator) { 426 return getPersistence() 427 .findBySessionId(sessionId, start, end, orderByComparator); 428 } 429 430 /** 431 * Returns the first user tracker in the ordered set where sessionId = ?. 432 * 433 * @param sessionId the session ID 434 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 435 * @return the first matching user tracker 436 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 437 */ 438 public static UserTracker findBySessionId_First( 439 java.lang.String sessionId, 440 OrderByComparator<UserTracker> orderByComparator) 441 throws com.liferay.portal.NoSuchUserTrackerException { 442 return getPersistence() 443 .findBySessionId_First(sessionId, orderByComparator); 444 } 445 446 /** 447 * Returns the first user tracker in the ordered set where sessionId = ?. 448 * 449 * @param sessionId the session ID 450 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 451 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 452 */ 453 public static UserTracker fetchBySessionId_First( 454 java.lang.String sessionId, 455 OrderByComparator<UserTracker> orderByComparator) { 456 return getPersistence() 457 .fetchBySessionId_First(sessionId, orderByComparator); 458 } 459 460 /** 461 * Returns the last user tracker in the ordered set where sessionId = ?. 462 * 463 * @param sessionId the session ID 464 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 465 * @return the last matching user tracker 466 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 467 */ 468 public static UserTracker findBySessionId_Last(java.lang.String sessionId, 469 OrderByComparator<UserTracker> orderByComparator) 470 throws com.liferay.portal.NoSuchUserTrackerException { 471 return getPersistence() 472 .findBySessionId_Last(sessionId, orderByComparator); 473 } 474 475 /** 476 * Returns the last user tracker in the ordered set where sessionId = ?. 477 * 478 * @param sessionId the session ID 479 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 480 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 481 */ 482 public static UserTracker fetchBySessionId_Last( 483 java.lang.String sessionId, 484 OrderByComparator<UserTracker> orderByComparator) { 485 return getPersistence() 486 .fetchBySessionId_Last(sessionId, orderByComparator); 487 } 488 489 /** 490 * Returns the user trackers before and after the current user tracker in the ordered set where sessionId = ?. 491 * 492 * @param userTrackerId the primary key of the current user tracker 493 * @param sessionId the session ID 494 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 495 * @return the previous, current, and next user tracker 496 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 497 */ 498 public static UserTracker[] findBySessionId_PrevAndNext( 499 long userTrackerId, java.lang.String sessionId, 500 OrderByComparator<UserTracker> orderByComparator) 501 throws com.liferay.portal.NoSuchUserTrackerException { 502 return getPersistence() 503 .findBySessionId_PrevAndNext(userTrackerId, sessionId, 504 orderByComparator); 505 } 506 507 /** 508 * Removes all the user trackers where sessionId = ? from the database. 509 * 510 * @param sessionId the session ID 511 */ 512 public static void removeBySessionId(java.lang.String sessionId) { 513 getPersistence().removeBySessionId(sessionId); 514 } 515 516 /** 517 * Returns the number of user trackers where sessionId = ?. 518 * 519 * @param sessionId the session ID 520 * @return the number of matching user trackers 521 */ 522 public static int countBySessionId(java.lang.String sessionId) { 523 return getPersistence().countBySessionId(sessionId); 524 } 525 526 /** 527 * Caches the user tracker in the entity cache if it is enabled. 528 * 529 * @param userTracker the user tracker 530 */ 531 public static void cacheResult(UserTracker userTracker) { 532 getPersistence().cacheResult(userTracker); 533 } 534 535 /** 536 * Caches the user trackers in the entity cache if it is enabled. 537 * 538 * @param userTrackers the user trackers 539 */ 540 public static void cacheResult(List<UserTracker> userTrackers) { 541 getPersistence().cacheResult(userTrackers); 542 } 543 544 /** 545 * Creates a new user tracker with the primary key. Does not add the user tracker to the database. 546 * 547 * @param userTrackerId the primary key for the new user tracker 548 * @return the new user tracker 549 */ 550 public static UserTracker create(long userTrackerId) { 551 return getPersistence().create(userTrackerId); 552 } 553 554 /** 555 * Removes the user tracker with the primary key from the database. Also notifies the appropriate model listeners. 556 * 557 * @param userTrackerId the primary key of the user tracker 558 * @return the user tracker that was removed 559 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 560 */ 561 public static UserTracker remove(long userTrackerId) 562 throws com.liferay.portal.NoSuchUserTrackerException { 563 return getPersistence().remove(userTrackerId); 564 } 565 566 public static UserTracker updateImpl(UserTracker userTracker) { 567 return getPersistence().updateImpl(userTracker); 568 } 569 570 /** 571 * Returns the user tracker with the primary key or throws a {@link NoSuchUserTrackerException} if it could not be found. 572 * 573 * @param userTrackerId the primary key of the user tracker 574 * @return the user tracker 575 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 576 */ 577 public static UserTracker findByPrimaryKey(long userTrackerId) 578 throws com.liferay.portal.NoSuchUserTrackerException { 579 return getPersistence().findByPrimaryKey(userTrackerId); 580 } 581 582 /** 583 * Returns the user tracker with the primary key or returns <code>null</code> if it could not be found. 584 * 585 * @param userTrackerId the primary key of the user tracker 586 * @return the user tracker, or <code>null</code> if a user tracker with the primary key could not be found 587 */ 588 public static UserTracker fetchByPrimaryKey(long userTrackerId) { 589 return getPersistence().fetchByPrimaryKey(userTrackerId); 590 } 591 592 public static java.util.Map<java.io.Serializable, UserTracker> fetchByPrimaryKeys( 593 java.util.Set<java.io.Serializable> primaryKeys) { 594 return getPersistence().fetchByPrimaryKeys(primaryKeys); 595 } 596 597 /** 598 * Returns all the user trackers. 599 * 600 * @return the user trackers 601 */ 602 public static List<UserTracker> findAll() { 603 return getPersistence().findAll(); 604 } 605 606 /** 607 * Returns a range of all the user trackers. 608 * 609 * <p> 610 * 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 UserTrackerModelImpl}. 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. 611 * </p> 612 * 613 * @param start the lower bound of the range of user trackers 614 * @param end the upper bound of the range of user trackers (not inclusive) 615 * @return the range of user trackers 616 */ 617 public static List<UserTracker> findAll(int start, int end) { 618 return getPersistence().findAll(start, end); 619 } 620 621 /** 622 * Returns an ordered range of all the user trackers. 623 * 624 * <p> 625 * 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 UserTrackerModelImpl}. 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. 626 * </p> 627 * 628 * @param start the lower bound of the range of user trackers 629 * @param end the upper bound of the range of user trackers (not inclusive) 630 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 631 * @return the ordered range of user trackers 632 */ 633 public static List<UserTracker> findAll(int start, int end, 634 OrderByComparator<UserTracker> orderByComparator) { 635 return getPersistence().findAll(start, end, orderByComparator); 636 } 637 638 /** 639 * Removes all the user trackers from the database. 640 */ 641 public static void removeAll() { 642 getPersistence().removeAll(); 643 } 644 645 /** 646 * Returns the number of user trackers. 647 * 648 * @return the number of user trackers 649 */ 650 public static int countAll() { 651 return getPersistence().countAll(); 652 } 653 654 public static UserTrackerPersistence getPersistence() { 655 if (_persistence == null) { 656 _persistence = (UserTrackerPersistence)PortalBeanLocatorUtil.locate(UserTrackerPersistence.class.getName()); 657 658 ReferenceRegistry.registerReference(UserTrackerUtil.class, 659 "_persistence"); 660 } 661 662 return _persistence; 663 } 664 665 /** 666 * @deprecated As of 6.2.0 667 */ 668 @Deprecated 669 public void setPersistence(UserTrackerPersistence persistence) { 670 } 671 672 private static UserTrackerPersistence _persistence; 673 }