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