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.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 */ 042 @Override 043 public com.liferay.portlet.messageboards.model.MBThreadFlag addMBThreadFlag( 044 com.liferay.portlet.messageboards.model.MBThreadFlag mbThreadFlag) { 045 return _mbThreadFlagLocalService.addMBThreadFlag(mbThreadFlag); 046 } 047 048 @Override 049 public void addThreadFlag(long userId, 050 com.liferay.portlet.messageboards.model.MBThread thread, 051 com.liferay.portal.service.ServiceContext serviceContext) 052 throws com.liferay.portal.kernel.exception.PortalException { 053 _mbThreadFlagLocalService.addThreadFlag(userId, thread, serviceContext); 054 } 055 056 /** 057 * Creates a new message boards thread flag with the primary key. Does not add the message boards thread flag to the database. 058 * 059 * @param threadFlagId the primary key for the new message boards thread flag 060 * @return the new message boards thread flag 061 */ 062 @Override 063 public com.liferay.portlet.messageboards.model.MBThreadFlag createMBThreadFlag( 064 long threadFlagId) { 065 return _mbThreadFlagLocalService.createMBThreadFlag(threadFlagId); 066 } 067 068 /** 069 * Deletes the message boards thread flag from the database. Also notifies the appropriate model listeners. 070 * 071 * @param mbThreadFlag the message boards thread flag 072 * @return the message boards thread flag that was removed 073 */ 074 @Override 075 public com.liferay.portlet.messageboards.model.MBThreadFlag deleteMBThreadFlag( 076 com.liferay.portlet.messageboards.model.MBThreadFlag mbThreadFlag) { 077 return _mbThreadFlagLocalService.deleteMBThreadFlag(mbThreadFlag); 078 } 079 080 /** 081 * Deletes the message boards thread flag with the primary key from the database. Also notifies the appropriate model listeners. 082 * 083 * @param threadFlagId the primary key of the message boards thread flag 084 * @return the message boards thread flag that was removed 085 * @throws PortalException if a message boards thread flag with the primary key could not be found 086 */ 087 @Override 088 public com.liferay.portlet.messageboards.model.MBThreadFlag deleteMBThreadFlag( 089 long threadFlagId) 090 throws com.liferay.portal.kernel.exception.PortalException { 091 return _mbThreadFlagLocalService.deleteMBThreadFlag(threadFlagId); 092 } 093 094 /** 095 * @throws PortalException 096 */ 097 @Override 098 public com.liferay.portal.model.PersistedModel deletePersistedModel( 099 com.liferay.portal.model.PersistedModel persistedModel) 100 throws com.liferay.portal.kernel.exception.PortalException { 101 return _mbThreadFlagLocalService.deletePersistedModel(persistedModel); 102 } 103 104 @Override 105 public void deleteThreadFlag( 106 com.liferay.portlet.messageboards.model.MBThreadFlag threadFlag) { 107 _mbThreadFlagLocalService.deleteThreadFlag(threadFlag); 108 } 109 110 @Override 111 public void deleteThreadFlag(long threadFlagId) 112 throws com.liferay.portal.kernel.exception.PortalException { 113 _mbThreadFlagLocalService.deleteThreadFlag(threadFlagId); 114 } 115 116 @Override 117 public void deleteThreadFlagsByThreadId(long threadId) { 118 _mbThreadFlagLocalService.deleteThreadFlagsByThreadId(threadId); 119 } 120 121 @Override 122 public void deleteThreadFlagsByUserId(long userId) { 123 _mbThreadFlagLocalService.deleteThreadFlagsByUserId(userId); 124 } 125 126 @Override 127 public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() { 128 return _mbThreadFlagLocalService.dynamicQuery(); 129 } 130 131 /** 132 * Performs a dynamic query on the database and returns the matching rows. 133 * 134 * @param dynamicQuery the dynamic query 135 * @return the matching rows 136 */ 137 @Override 138 public <T> java.util.List<T> dynamicQuery( 139 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 140 return _mbThreadFlagLocalService.dynamicQuery(dynamicQuery); 141 } 142 143 /** 144 * Performs a dynamic query on the database and returns a range of the matching rows. 145 * 146 * <p> 147 * 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. 148 * </p> 149 * 150 * @param dynamicQuery the dynamic query 151 * @param start the lower bound of the range of model instances 152 * @param end the upper bound of the range of model instances (not inclusive) 153 * @return the range of matching rows 154 */ 155 @Override 156 public <T> java.util.List<T> dynamicQuery( 157 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 158 int end) { 159 return _mbThreadFlagLocalService.dynamicQuery(dynamicQuery, start, end); 160 } 161 162 /** 163 * Performs a dynamic query on the database and returns an ordered range of the matching rows. 164 * 165 * <p> 166 * 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. 167 * </p> 168 * 169 * @param dynamicQuery the dynamic query 170 * @param start the lower bound of the range of model instances 171 * @param end the upper bound of the range of model instances (not inclusive) 172 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 173 * @return the ordered range of matching rows 174 */ 175 @Override 176 public <T> java.util.List<T> dynamicQuery( 177 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 178 int end, 179 com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) { 180 return _mbThreadFlagLocalService.dynamicQuery(dynamicQuery, start, end, 181 orderByComparator); 182 } 183 184 /** 185 * Returns the number of rows matching the dynamic query. 186 * 187 * @param dynamicQuery the dynamic query 188 * @return the number of rows matching the dynamic query 189 */ 190 @Override 191 public long dynamicQueryCount( 192 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 193 return _mbThreadFlagLocalService.dynamicQueryCount(dynamicQuery); 194 } 195 196 /** 197 * Returns the number of rows matching the dynamic query. 198 * 199 * @param dynamicQuery the dynamic query 200 * @param projection the projection to apply to the query 201 * @return the number of rows matching the dynamic query 202 */ 203 @Override 204 public long dynamicQueryCount( 205 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, 206 com.liferay.portal.kernel.dao.orm.Projection projection) { 207 return _mbThreadFlagLocalService.dynamicQueryCount(dynamicQuery, 208 projection); 209 } 210 211 @Override 212 public com.liferay.portlet.messageboards.model.MBThreadFlag fetchMBThreadFlag( 213 long threadFlagId) { 214 return _mbThreadFlagLocalService.fetchMBThreadFlag(threadFlagId); 215 } 216 217 /** 218 * Returns the message boards thread flag matching the UUID and group. 219 * 220 * @param uuid the message boards thread flag's UUID 221 * @param groupId the primary key of the group 222 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 223 */ 224 @Override 225 public com.liferay.portlet.messageboards.model.MBThreadFlag fetchMBThreadFlagByUuidAndGroupId( 226 java.lang.String uuid, long groupId) { 227 return _mbThreadFlagLocalService.fetchMBThreadFlagByUuidAndGroupId(uuid, 228 groupId); 229 } 230 231 @Override 232 public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() { 233 return _mbThreadFlagLocalService.getActionableDynamicQuery(); 234 } 235 236 /** 237 * Returns the Spring bean ID for this bean. 238 * 239 * @return the Spring bean ID for this bean 240 */ 241 @Override 242 public java.lang.String getBeanIdentifier() { 243 return _mbThreadFlagLocalService.getBeanIdentifier(); 244 } 245 246 @Override 247 public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery( 248 com.liferay.portal.kernel.lar.PortletDataContext portletDataContext) { 249 return _mbThreadFlagLocalService.getExportActionableDynamicQuery(portletDataContext); 250 } 251 252 /** 253 * Returns the message boards thread flag with the primary key. 254 * 255 * @param threadFlagId the primary key of the message boards thread flag 256 * @return the message boards thread flag 257 * @throws PortalException if a message boards thread flag with the primary key could not be found 258 */ 259 @Override 260 public com.liferay.portlet.messageboards.model.MBThreadFlag getMBThreadFlag( 261 long threadFlagId) 262 throws com.liferay.portal.kernel.exception.PortalException { 263 return _mbThreadFlagLocalService.getMBThreadFlag(threadFlagId); 264 } 265 266 /** 267 * Returns the message boards thread flag matching the UUID and group. 268 * 269 * @param uuid the message boards thread flag's UUID 270 * @param groupId the primary key of the group 271 * @return the matching message boards thread flag 272 * @throws PortalException if a matching message boards thread flag could not be found 273 */ 274 @Override 275 public com.liferay.portlet.messageboards.model.MBThreadFlag getMBThreadFlagByUuidAndGroupId( 276 java.lang.String uuid, long groupId) 277 throws com.liferay.portal.kernel.exception.PortalException { 278 return _mbThreadFlagLocalService.getMBThreadFlagByUuidAndGroupId(uuid, 279 groupId); 280 } 281 282 /** 283 * Returns a range of all the message boards thread flags. 284 * 285 * <p> 286 * 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. 287 * </p> 288 * 289 * @param start the lower bound of the range of message boards thread flags 290 * @param end the upper bound of the range of message boards thread flags (not inclusive) 291 * @return the range of message boards thread flags 292 */ 293 @Override 294 public java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> getMBThreadFlags( 295 int start, int end) { 296 return _mbThreadFlagLocalService.getMBThreadFlags(start, end); 297 } 298 299 /** 300 * Returns all the message boards thread flags matching the UUID and company. 301 * 302 * @param uuid the UUID of the message boards thread flags 303 * @param companyId the primary key of the company 304 * @return the matching message boards thread flags, or an empty list if no matches were found 305 */ 306 @Override 307 public java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> getMBThreadFlagsByUuidAndCompanyId( 308 java.lang.String uuid, long companyId) { 309 return _mbThreadFlagLocalService.getMBThreadFlagsByUuidAndCompanyId(uuid, 310 companyId); 311 } 312 313 /** 314 * Returns a range of message boards thread flags matching the UUID and company. 315 * 316 * @param uuid the UUID of the message boards thread flags 317 * @param companyId the primary key of the company 318 * @param start the lower bound of the range of message boards thread flags 319 * @param end the upper bound of the range of message boards thread flags (not inclusive) 320 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 321 * @return the range of matching message boards thread flags, or an empty list if no matches were found 322 */ 323 @Override 324 public java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> getMBThreadFlagsByUuidAndCompanyId( 325 java.lang.String uuid, long companyId, int start, int end, 326 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 327 return _mbThreadFlagLocalService.getMBThreadFlagsByUuidAndCompanyId(uuid, 328 companyId, start, end, orderByComparator); 329 } 330 331 /** 332 * Returns the number of message boards thread flags. 333 * 334 * @return the number of message boards thread flags 335 */ 336 @Override 337 public int getMBThreadFlagsCount() { 338 return _mbThreadFlagLocalService.getMBThreadFlagsCount(); 339 } 340 341 @Override 342 public com.liferay.portal.model.PersistedModel getPersistedModel( 343 java.io.Serializable primaryKeyObj) 344 throws com.liferay.portal.kernel.exception.PortalException { 345 return _mbThreadFlagLocalService.getPersistedModel(primaryKeyObj); 346 } 347 348 @Override 349 public com.liferay.portlet.messageboards.model.MBThreadFlag getThreadFlag( 350 long userId, com.liferay.portlet.messageboards.model.MBThread thread) 351 throws com.liferay.portal.kernel.exception.PortalException { 352 return _mbThreadFlagLocalService.getThreadFlag(userId, thread); 353 } 354 355 @Override 356 public boolean hasThreadFlag(long userId, 357 com.liferay.portlet.messageboards.model.MBThread thread) 358 throws com.liferay.portal.kernel.exception.PortalException { 359 return _mbThreadFlagLocalService.hasThreadFlag(userId, thread); 360 } 361 362 /** 363 * Sets the Spring bean ID for this bean. 364 * 365 * @param beanIdentifier the Spring bean ID for this bean 366 */ 367 @Override 368 public void setBeanIdentifier(java.lang.String beanIdentifier) { 369 _mbThreadFlagLocalService.setBeanIdentifier(beanIdentifier); 370 } 371 372 /** 373 * Updates the message boards thread flag in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 374 * 375 * @param mbThreadFlag the message boards thread flag 376 * @return the message boards thread flag that was updated 377 */ 378 @Override 379 public com.liferay.portlet.messageboards.model.MBThreadFlag updateMBThreadFlag( 380 com.liferay.portlet.messageboards.model.MBThreadFlag mbThreadFlag) { 381 return _mbThreadFlagLocalService.updateMBThreadFlag(mbThreadFlag); 382 } 383 384 /** 385 * @deprecated As of 6.1.0, replaced by {@link #getWrappedService} 386 */ 387 @Deprecated 388 public MBThreadFlagLocalService getWrappedMBThreadFlagLocalService() { 389 return _mbThreadFlagLocalService; 390 } 391 392 /** 393 * @deprecated As of 6.1.0, replaced by {@link #setWrappedService} 394 */ 395 @Deprecated 396 public void setWrappedMBThreadFlagLocalService( 397 MBThreadFlagLocalService mbThreadFlagLocalService) { 398 _mbThreadFlagLocalService = mbThreadFlagLocalService; 399 } 400 401 @Override 402 public MBThreadFlagLocalService getWrappedService() { 403 return _mbThreadFlagLocalService; 404 } 405 406 @Override 407 public void setWrappedService( 408 MBThreadFlagLocalService mbThreadFlagLocalService) { 409 _mbThreadFlagLocalService = mbThreadFlagLocalService; 410 } 411 412 private MBThreadFlagLocalService _mbThreadFlagLocalService; 413 }