001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.messageboards.service; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.service.ServiceWrapper; 020 021 /** 022 * Provides a wrapper for {@link MBThreadFlagLocalService}. 023 * 024 * @author Brian Wing Shun Chan 025 * @see MBThreadFlagLocalService 026 * @generated 027 */ 028 @ProviderType 029 public class MBThreadFlagLocalServiceWrapper implements MBThreadFlagLocalService, 030 ServiceWrapper<MBThreadFlagLocalService> { 031 public MBThreadFlagLocalServiceWrapper( 032 MBThreadFlagLocalService mbThreadFlagLocalService) { 033 _mbThreadFlagLocalService = mbThreadFlagLocalService; 034 } 035 036 /** 037 * Adds the message boards thread flag to the database. Also notifies the appropriate model listeners. 038 * 039 * @param mbThreadFlag the message boards thread flag 040 * @return the message boards thread flag that was added 041 * @throws SystemException if a system exception occurred 042 */ 043 @Override 044 public com.liferay.portlet.messageboards.model.MBThreadFlag addMBThreadFlag( 045 com.liferay.portlet.messageboards.model.MBThreadFlag mbThreadFlag) 046 throws com.liferay.portal.kernel.exception.SystemException { 047 return _mbThreadFlagLocalService.addMBThreadFlag(mbThreadFlag); 048 } 049 050 /** 051 * Creates a new message boards thread flag with the primary key. Does not add the message boards thread flag to the database. 052 * 053 * @param threadFlagId the primary key for the new message boards thread flag 054 * @return the new message boards thread flag 055 */ 056 @Override 057 public com.liferay.portlet.messageboards.model.MBThreadFlag createMBThreadFlag( 058 long threadFlagId) { 059 return _mbThreadFlagLocalService.createMBThreadFlag(threadFlagId); 060 } 061 062 /** 063 * Deletes the message boards thread flag with the primary key from the database. Also notifies the appropriate model listeners. 064 * 065 * @param threadFlagId the primary key of the message boards thread flag 066 * @return the message boards thread flag that was removed 067 * @throws PortalException if a message boards thread flag with the primary key could not be found 068 * @throws SystemException if a system exception occurred 069 */ 070 @Override 071 public com.liferay.portlet.messageboards.model.MBThreadFlag deleteMBThreadFlag( 072 long threadFlagId) 073 throws com.liferay.portal.kernel.exception.PortalException, 074 com.liferay.portal.kernel.exception.SystemException { 075 return _mbThreadFlagLocalService.deleteMBThreadFlag(threadFlagId); 076 } 077 078 /** 079 * Deletes the message boards thread flag from the database. Also notifies the appropriate model listeners. 080 * 081 * @param mbThreadFlag the message boards thread flag 082 * @return the message boards thread flag that was removed 083 * @throws SystemException if a system exception occurred 084 */ 085 @Override 086 public com.liferay.portlet.messageboards.model.MBThreadFlag deleteMBThreadFlag( 087 com.liferay.portlet.messageboards.model.MBThreadFlag mbThreadFlag) 088 throws com.liferay.portal.kernel.exception.SystemException { 089 return _mbThreadFlagLocalService.deleteMBThreadFlag(mbThreadFlag); 090 } 091 092 @Override 093 public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() { 094 return _mbThreadFlagLocalService.dynamicQuery(); 095 } 096 097 /** 098 * Performs a dynamic query on the database and returns the matching rows. 099 * 100 * @param dynamicQuery the dynamic query 101 * @return the matching rows 102 * @throws SystemException if a system exception occurred 103 */ 104 @Override 105 @SuppressWarnings("rawtypes") 106 public java.util.List dynamicQuery( 107 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) 108 throws com.liferay.portal.kernel.exception.SystemException { 109 return _mbThreadFlagLocalService.dynamicQuery(dynamicQuery); 110 } 111 112 /** 113 * Performs a dynamic query on the database and returns a range of the matching rows. 114 * 115 * <p> 116 * 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.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 117 * </p> 118 * 119 * @param dynamicQuery the dynamic query 120 * @param start the lower bound of the range of model instances 121 * @param end the upper bound of the range of model instances (not inclusive) 122 * @return the range of matching rows 123 * @throws SystemException if a system exception occurred 124 */ 125 @Override 126 @SuppressWarnings("rawtypes") 127 public java.util.List dynamicQuery( 128 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 129 int end) throws com.liferay.portal.kernel.exception.SystemException { 130 return _mbThreadFlagLocalService.dynamicQuery(dynamicQuery, start, end); 131 } 132 133 /** 134 * Performs a dynamic query on the database and returns an ordered range of the matching rows. 135 * 136 * <p> 137 * 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.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 138 * </p> 139 * 140 * @param dynamicQuery the dynamic query 141 * @param start the lower bound of the range of model instances 142 * @param end the upper bound of the range of model instances (not inclusive) 143 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 144 * @return the ordered range of matching rows 145 * @throws SystemException if a system exception occurred 146 */ 147 @Override 148 @SuppressWarnings("rawtypes") 149 public java.util.List dynamicQuery( 150 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 151 int end, 152 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 153 throws com.liferay.portal.kernel.exception.SystemException { 154 return _mbThreadFlagLocalService.dynamicQuery(dynamicQuery, start, end, 155 orderByComparator); 156 } 157 158 /** 159 * Returns the number of rows that match the dynamic query. 160 * 161 * @param dynamicQuery the dynamic query 162 * @return the number of rows that match the dynamic query 163 * @throws SystemException if a system exception occurred 164 */ 165 @Override 166 public long dynamicQueryCount( 167 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) 168 throws com.liferay.portal.kernel.exception.SystemException { 169 return _mbThreadFlagLocalService.dynamicQueryCount(dynamicQuery); 170 } 171 172 /** 173 * Returns the number of rows that match the dynamic query. 174 * 175 * @param dynamicQuery the dynamic query 176 * @param projection the projection to apply to the query 177 * @return the number of rows that match the dynamic query 178 * @throws SystemException if a system exception occurred 179 */ 180 @Override 181 public long dynamicQueryCount( 182 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, 183 com.liferay.portal.kernel.dao.orm.Projection projection) 184 throws com.liferay.portal.kernel.exception.SystemException { 185 return _mbThreadFlagLocalService.dynamicQueryCount(dynamicQuery, 186 projection); 187 } 188 189 @Override 190 public com.liferay.portlet.messageboards.model.MBThreadFlag fetchMBThreadFlag( 191 long threadFlagId) 192 throws com.liferay.portal.kernel.exception.SystemException { 193 return _mbThreadFlagLocalService.fetchMBThreadFlag(threadFlagId); 194 } 195 196 /** 197 * Returns the message boards thread flag with the matching UUID and company. 198 * 199 * @param uuid the message boards thread flag's UUID 200 * @param companyId the primary key of the company 201 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 202 * @throws SystemException if a system exception occurred 203 */ 204 @Override 205 public com.liferay.portlet.messageboards.model.MBThreadFlag fetchMBThreadFlagByUuidAndCompanyId( 206 java.lang.String uuid, long companyId) 207 throws com.liferay.portal.kernel.exception.SystemException { 208 return _mbThreadFlagLocalService.fetchMBThreadFlagByUuidAndCompanyId(uuid, 209 companyId); 210 } 211 212 /** 213 * Returns the message boards thread flag matching the UUID and group. 214 * 215 * @param uuid the message boards thread flag's UUID 216 * @param groupId the primary key of the group 217 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 218 * @throws SystemException if a system exception occurred 219 */ 220 @Override 221 public com.liferay.portlet.messageboards.model.MBThreadFlag fetchMBThreadFlagByUuidAndGroupId( 222 java.lang.String uuid, long groupId) 223 throws com.liferay.portal.kernel.exception.SystemException { 224 return _mbThreadFlagLocalService.fetchMBThreadFlagByUuidAndGroupId(uuid, 225 groupId); 226 } 227 228 /** 229 * Returns the message boards thread flag with the primary key. 230 * 231 * @param threadFlagId the primary key of the message boards thread flag 232 * @return the message boards thread flag 233 * @throws PortalException if a message boards thread flag with the primary key could not be found 234 * @throws SystemException if a system exception occurred 235 */ 236 @Override 237 public com.liferay.portlet.messageboards.model.MBThreadFlag getMBThreadFlag( 238 long threadFlagId) 239 throws com.liferay.portal.kernel.exception.PortalException, 240 com.liferay.portal.kernel.exception.SystemException { 241 return _mbThreadFlagLocalService.getMBThreadFlag(threadFlagId); 242 } 243 244 @Override 245 public com.liferay.portal.model.PersistedModel getPersistedModel( 246 java.io.Serializable primaryKeyObj) 247 throws com.liferay.portal.kernel.exception.PortalException, 248 com.liferay.portal.kernel.exception.SystemException { 249 return _mbThreadFlagLocalService.getPersistedModel(primaryKeyObj); 250 } 251 252 /** 253 * Returns the message boards thread flag with the matching UUID and company. 254 * 255 * @param uuid the message boards thread flag's UUID 256 * @param companyId the primary key of the company 257 * @return the matching message boards thread flag 258 * @throws PortalException if a matching message boards thread flag could not be found 259 * @throws SystemException if a system exception occurred 260 */ 261 @Override 262 public com.liferay.portlet.messageboards.model.MBThreadFlag getMBThreadFlagByUuidAndCompanyId( 263 java.lang.String uuid, long companyId) 264 throws com.liferay.portal.kernel.exception.PortalException, 265 com.liferay.portal.kernel.exception.SystemException { 266 return _mbThreadFlagLocalService.getMBThreadFlagByUuidAndCompanyId(uuid, 267 companyId); 268 } 269 270 /** 271 * Returns the message boards thread flag matching the UUID and group. 272 * 273 * @param uuid the message boards thread flag's UUID 274 * @param groupId the primary key of the group 275 * @return the matching message boards thread flag 276 * @throws PortalException if a matching message boards thread flag could not be found 277 * @throws SystemException if a system exception occurred 278 */ 279 @Override 280 public com.liferay.portlet.messageboards.model.MBThreadFlag getMBThreadFlagByUuidAndGroupId( 281 java.lang.String uuid, long groupId) 282 throws com.liferay.portal.kernel.exception.PortalException, 283 com.liferay.portal.kernel.exception.SystemException { 284 return _mbThreadFlagLocalService.getMBThreadFlagByUuidAndGroupId(uuid, 285 groupId); 286 } 287 288 /** 289 * Returns a range of all the message boards thread flags. 290 * 291 * <p> 292 * 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.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 293 * </p> 294 * 295 * @param start the lower bound of the range of message boards thread flags 296 * @param end the upper bound of the range of message boards thread flags (not inclusive) 297 * @return the range of message boards thread flags 298 * @throws SystemException if a system exception occurred 299 */ 300 @Override 301 public java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> getMBThreadFlags( 302 int start, int end) 303 throws com.liferay.portal.kernel.exception.SystemException { 304 return _mbThreadFlagLocalService.getMBThreadFlags(start, end); 305 } 306 307 /** 308 * Returns the number of message boards thread flags. 309 * 310 * @return the number of message boards thread flags 311 * @throws SystemException if a system exception occurred 312 */ 313 @Override 314 public int getMBThreadFlagsCount() 315 throws com.liferay.portal.kernel.exception.SystemException { 316 return _mbThreadFlagLocalService.getMBThreadFlagsCount(); 317 } 318 319 /** 320 * Updates the message boards thread flag in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 321 * 322 * @param mbThreadFlag the message boards thread flag 323 * @return the message boards thread flag that was updated 324 * @throws SystemException if a system exception occurred 325 */ 326 @Override 327 public com.liferay.portlet.messageboards.model.MBThreadFlag updateMBThreadFlag( 328 com.liferay.portlet.messageboards.model.MBThreadFlag mbThreadFlag) 329 throws com.liferay.portal.kernel.exception.SystemException { 330 return _mbThreadFlagLocalService.updateMBThreadFlag(mbThreadFlag); 331 } 332 333 /** 334 * Returns the Spring bean ID for this bean. 335 * 336 * @return the Spring bean ID for this bean 337 */ 338 @Override 339 public java.lang.String getBeanIdentifier() { 340 return _mbThreadFlagLocalService.getBeanIdentifier(); 341 } 342 343 /** 344 * Sets the Spring bean ID for this bean. 345 * 346 * @param beanIdentifier the Spring bean ID for this bean 347 */ 348 @Override 349 public void setBeanIdentifier(java.lang.String beanIdentifier) { 350 _mbThreadFlagLocalService.setBeanIdentifier(beanIdentifier); 351 } 352 353 @Override 354 public void addThreadFlag(long userId, 355 com.liferay.portlet.messageboards.model.MBThread thread, 356 com.liferay.portal.service.ServiceContext serviceContext) 357 throws com.liferay.portal.kernel.exception.PortalException, 358 com.liferay.portal.kernel.exception.SystemException { 359 _mbThreadFlagLocalService.addThreadFlag(userId, thread, serviceContext); 360 } 361 362 @Override 363 public void deleteThreadFlag(long threadFlagId) 364 throws com.liferay.portal.kernel.exception.PortalException, 365 com.liferay.portal.kernel.exception.SystemException { 366 _mbThreadFlagLocalService.deleteThreadFlag(threadFlagId); 367 } 368 369 @Override 370 public void deleteThreadFlag( 371 com.liferay.portlet.messageboards.model.MBThreadFlag threadFlag) 372 throws com.liferay.portal.kernel.exception.SystemException { 373 _mbThreadFlagLocalService.deleteThreadFlag(threadFlag); 374 } 375 376 @Override 377 public void deleteThreadFlagsByThreadId(long threadId) 378 throws com.liferay.portal.kernel.exception.SystemException { 379 _mbThreadFlagLocalService.deleteThreadFlagsByThreadId(threadId); 380 } 381 382 @Override 383 public void deleteThreadFlagsByUserId(long userId) 384 throws com.liferay.portal.kernel.exception.SystemException { 385 _mbThreadFlagLocalService.deleteThreadFlagsByUserId(userId); 386 } 387 388 @Override 389 public com.liferay.portlet.messageboards.model.MBThreadFlag getThreadFlag( 390 long userId, com.liferay.portlet.messageboards.model.MBThread thread) 391 throws com.liferay.portal.kernel.exception.PortalException, 392 com.liferay.portal.kernel.exception.SystemException { 393 return _mbThreadFlagLocalService.getThreadFlag(userId, thread); 394 } 395 396 @Override 397 public boolean hasThreadFlag(long userId, 398 com.liferay.portlet.messageboards.model.MBThread thread) 399 throws com.liferay.portal.kernel.exception.PortalException, 400 com.liferay.portal.kernel.exception.SystemException { 401 return _mbThreadFlagLocalService.hasThreadFlag(userId, thread); 402 } 403 404 /** 405 * @deprecated As of 6.1.0, replaced by {@link #getWrappedService} 406 */ 407 public MBThreadFlagLocalService getWrappedMBThreadFlagLocalService() { 408 return _mbThreadFlagLocalService; 409 } 410 411 /** 412 * @deprecated As of 6.1.0, replaced by {@link #setWrappedService} 413 */ 414 public void setWrappedMBThreadFlagLocalService( 415 MBThreadFlagLocalService mbThreadFlagLocalService) { 416 _mbThreadFlagLocalService = mbThreadFlagLocalService; 417 } 418 419 @Override 420 public MBThreadFlagLocalService getWrappedService() { 421 return _mbThreadFlagLocalService; 422 } 423 424 @Override 425 public void setWrappedService( 426 MBThreadFlagLocalService mbThreadFlagLocalService) { 427 _mbThreadFlagLocalService = mbThreadFlagLocalService; 428 } 429 430 private MBThreadFlagLocalService _mbThreadFlagLocalService; 431 }