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; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 /** 020 * Provides a wrapper for {@link UserTrackerLocalService}. 021 * 022 * @author Brian Wing Shun Chan 023 * @see UserTrackerLocalService 024 * @generated 025 */ 026 @ProviderType 027 public class UserTrackerLocalServiceWrapper implements UserTrackerLocalService, 028 ServiceWrapper<UserTrackerLocalService> { 029 public UserTrackerLocalServiceWrapper( 030 UserTrackerLocalService userTrackerLocalService) { 031 _userTrackerLocalService = userTrackerLocalService; 032 } 033 034 @Override 035 public com.liferay.portal.model.UserTracker addUserTracker(long companyId, 036 long userId, java.util.Date modifiedDate, java.lang.String sessionId, 037 java.lang.String remoteAddr, java.lang.String remoteHost, 038 java.lang.String userAgent, 039 java.util.List<com.liferay.portal.model.UserTrackerPath> userTrackerPaths) { 040 return _userTrackerLocalService.addUserTracker(companyId, userId, 041 modifiedDate, sessionId, remoteAddr, remoteHost, userAgent, 042 userTrackerPaths); 043 } 044 045 /** 046 * Adds the user tracker to the database. Also notifies the appropriate model listeners. 047 * 048 * @param userTracker the user tracker 049 * @return the user tracker that was added 050 */ 051 @Override 052 public com.liferay.portal.model.UserTracker addUserTracker( 053 com.liferay.portal.model.UserTracker userTracker) { 054 return _userTrackerLocalService.addUserTracker(userTracker); 055 } 056 057 /** 058 * Creates a new user tracker with the primary key. Does not add the user tracker to the database. 059 * 060 * @param userTrackerId the primary key for the new user tracker 061 * @return the new user tracker 062 */ 063 @Override 064 public com.liferay.portal.model.UserTracker createUserTracker( 065 long userTrackerId) { 066 return _userTrackerLocalService.createUserTracker(userTrackerId); 067 } 068 069 /** 070 * @throws PortalException 071 */ 072 @Override 073 public com.liferay.portal.model.PersistedModel deletePersistedModel( 074 com.liferay.portal.model.PersistedModel persistedModel) 075 throws com.liferay.portal.kernel.exception.PortalException { 076 return _userTrackerLocalService.deletePersistedModel(persistedModel); 077 } 078 079 /** 080 * Deletes the user tracker from the database. Also notifies the appropriate model listeners. 081 * 082 * @param userTracker the user tracker 083 * @return the user tracker that was removed 084 */ 085 @Override 086 public com.liferay.portal.model.UserTracker deleteUserTracker( 087 com.liferay.portal.model.UserTracker userTracker) { 088 return _userTrackerLocalService.deleteUserTracker(userTracker); 089 } 090 091 /** 092 * Deletes the user tracker with the primary key from the database. Also notifies the appropriate model listeners. 093 * 094 * @param userTrackerId the primary key of the user tracker 095 * @return the user tracker that was removed 096 * @throws PortalException if a user tracker with the primary key could not be found 097 */ 098 @Override 099 public com.liferay.portal.model.UserTracker deleteUserTracker( 100 long userTrackerId) 101 throws com.liferay.portal.kernel.exception.PortalException { 102 return _userTrackerLocalService.deleteUserTracker(userTrackerId); 103 } 104 105 @Override 106 public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() { 107 return _userTrackerLocalService.dynamicQuery(); 108 } 109 110 /** 111 * Performs a dynamic query on the database and returns the matching rows. 112 * 113 * @param dynamicQuery the dynamic query 114 * @return the matching rows 115 */ 116 @Override 117 public <T> java.util.List<T> dynamicQuery( 118 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 119 return _userTrackerLocalService.dynamicQuery(dynamicQuery); 120 } 121 122 /** 123 * Performs a dynamic query on the database and returns a range of the matching rows. 124 * 125 * <p> 126 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 127 * </p> 128 * 129 * @param dynamicQuery the dynamic query 130 * @param start the lower bound of the range of model instances 131 * @param end the upper bound of the range of model instances (not inclusive) 132 * @return the range of matching rows 133 */ 134 @Override 135 public <T> java.util.List<T> dynamicQuery( 136 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 137 int end) { 138 return _userTrackerLocalService.dynamicQuery(dynamicQuery, start, end); 139 } 140 141 /** 142 * Performs a dynamic query on the database and returns an ordered range of the matching rows. 143 * 144 * <p> 145 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 146 * </p> 147 * 148 * @param dynamicQuery the dynamic query 149 * @param start the lower bound of the range of model instances 150 * @param end the upper bound of the range of model instances (not inclusive) 151 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 152 * @return the ordered range of matching rows 153 */ 154 @Override 155 public <T> java.util.List<T> dynamicQuery( 156 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 157 int end, 158 com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) { 159 return _userTrackerLocalService.dynamicQuery(dynamicQuery, start, end, 160 orderByComparator); 161 } 162 163 /** 164 * Returns the number of rows matching the dynamic query. 165 * 166 * @param dynamicQuery the dynamic query 167 * @return the number of rows matching the dynamic query 168 */ 169 @Override 170 public long dynamicQueryCount( 171 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 172 return _userTrackerLocalService.dynamicQueryCount(dynamicQuery); 173 } 174 175 /** 176 * Returns the number of rows matching the dynamic query. 177 * 178 * @param dynamicQuery the dynamic query 179 * @param projection the projection to apply to the query 180 * @return the number of rows matching the dynamic query 181 */ 182 @Override 183 public long dynamicQueryCount( 184 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, 185 com.liferay.portal.kernel.dao.orm.Projection projection) { 186 return _userTrackerLocalService.dynamicQueryCount(dynamicQuery, 187 projection); 188 } 189 190 @Override 191 public com.liferay.portal.model.UserTracker fetchUserTracker( 192 long userTrackerId) { 193 return _userTrackerLocalService.fetchUserTracker(userTrackerId); 194 } 195 196 @Override 197 public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() { 198 return _userTrackerLocalService.getActionableDynamicQuery(); 199 } 200 201 /** 202 * Returns the Spring bean ID for this bean. 203 * 204 * @return the Spring bean ID for this bean 205 */ 206 @Override 207 public java.lang.String getBeanIdentifier() { 208 return _userTrackerLocalService.getBeanIdentifier(); 209 } 210 211 @Override 212 public com.liferay.portal.model.PersistedModel getPersistedModel( 213 java.io.Serializable primaryKeyObj) 214 throws com.liferay.portal.kernel.exception.PortalException { 215 return _userTrackerLocalService.getPersistedModel(primaryKeyObj); 216 } 217 218 /** 219 * Returns the user tracker with the primary key. 220 * 221 * @param userTrackerId the primary key of the user tracker 222 * @return the user tracker 223 * @throws PortalException if a user tracker with the primary key could not be found 224 */ 225 @Override 226 public com.liferay.portal.model.UserTracker getUserTracker( 227 long userTrackerId) 228 throws com.liferay.portal.kernel.exception.PortalException { 229 return _userTrackerLocalService.getUserTracker(userTrackerId); 230 } 231 232 @Override 233 public java.util.List<com.liferay.portal.model.UserTracker> getUserTrackers( 234 long companyId, int start, int end) { 235 return _userTrackerLocalService.getUserTrackers(companyId, start, end); 236 } 237 238 /** 239 * Returns a range of all the user trackers. 240 * 241 * <p> 242 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 243 * </p> 244 * 245 * @param start the lower bound of the range of user trackers 246 * @param end the upper bound of the range of user trackers (not inclusive) 247 * @return the range of user trackers 248 */ 249 @Override 250 public java.util.List<com.liferay.portal.model.UserTracker> getUserTrackers( 251 int start, int end) { 252 return _userTrackerLocalService.getUserTrackers(start, end); 253 } 254 255 /** 256 * Returns the number of user trackers. 257 * 258 * @return the number of user trackers 259 */ 260 @Override 261 public int getUserTrackersCount() { 262 return _userTrackerLocalService.getUserTrackersCount(); 263 } 264 265 /** 266 * Sets the Spring bean ID for this bean. 267 * 268 * @param beanIdentifier the Spring bean ID for this bean 269 */ 270 @Override 271 public void setBeanIdentifier(java.lang.String beanIdentifier) { 272 _userTrackerLocalService.setBeanIdentifier(beanIdentifier); 273 } 274 275 /** 276 * Updates the user tracker in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 277 * 278 * @param userTracker the user tracker 279 * @return the user tracker that was updated 280 */ 281 @Override 282 public com.liferay.portal.model.UserTracker updateUserTracker( 283 com.liferay.portal.model.UserTracker userTracker) { 284 return _userTrackerLocalService.updateUserTracker(userTracker); 285 } 286 287 /** 288 * @deprecated As of 6.1.0, replaced by {@link #getWrappedService} 289 */ 290 @Deprecated 291 public UserTrackerLocalService getWrappedUserTrackerLocalService() { 292 return _userTrackerLocalService; 293 } 294 295 /** 296 * @deprecated As of 6.1.0, replaced by {@link #setWrappedService} 297 */ 298 @Deprecated 299 public void setWrappedUserTrackerLocalService( 300 UserTrackerLocalService userTrackerLocalService) { 301 _userTrackerLocalService = userTrackerLocalService; 302 } 303 304 @Override 305 public UserTrackerLocalService getWrappedService() { 306 return _userTrackerLocalService; 307 } 308 309 @Override 310 public void setWrappedService( 311 UserTrackerLocalService userTrackerLocalService) { 312 _userTrackerLocalService = userTrackerLocalService; 313 } 314 315 private UserTrackerLocalService _userTrackerLocalService; 316 }