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 @Override 238 public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery( 239 com.liferay.portlet.exportimport.lar.PortletDataContext portletDataContext) { 240 return _mbThreadFlagLocalService.getExportActionableDynamicQuery(portletDataContext); 241 } 242 243 @Override 244 public com.liferay.portal.kernel.dao.orm.IndexableActionableDynamicQuery getIndexableActionableDynamicQuery() { 245 return _mbThreadFlagLocalService.getIndexableActionableDynamicQuery(); 246 } 247 248 /** 249 * Returns the message boards thread flag with the primary key. 250 * 251 * @param threadFlagId the primary key of the message boards thread flag 252 * @return the message boards thread flag 253 * @throws PortalException if a message boards thread flag with the primary key could not be found 254 */ 255 @Override 256 public com.liferay.portlet.messageboards.model.MBThreadFlag getMBThreadFlag( 257 long threadFlagId) 258 throws com.liferay.portal.kernel.exception.PortalException { 259 return _mbThreadFlagLocalService.getMBThreadFlag(threadFlagId); 260 } 261 262 /** 263 * Returns the message boards thread flag matching the UUID and group. 264 * 265 * @param uuid the message boards thread flag's UUID 266 * @param groupId the primary key of the group 267 * @return the matching message boards thread flag 268 * @throws PortalException if a matching message boards thread flag could not be found 269 */ 270 @Override 271 public com.liferay.portlet.messageboards.model.MBThreadFlag getMBThreadFlagByUuidAndGroupId( 272 java.lang.String uuid, long groupId) 273 throws com.liferay.portal.kernel.exception.PortalException { 274 return _mbThreadFlagLocalService.getMBThreadFlagByUuidAndGroupId(uuid, 275 groupId); 276 } 277 278 /** 279 * Returns a range of all the message boards thread flags. 280 * 281 * <p> 282 * 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. 283 * </p> 284 * 285 * @param start the lower bound of the range of message boards thread flags 286 * @param end the upper bound of the range of message boards thread flags (not inclusive) 287 * @return the range of message boards thread flags 288 */ 289 @Override 290 public java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> getMBThreadFlags( 291 int start, int end) { 292 return _mbThreadFlagLocalService.getMBThreadFlags(start, end); 293 } 294 295 /** 296 * Returns all the message boards thread flags matching the UUID and company. 297 * 298 * @param uuid the UUID of the message boards thread flags 299 * @param companyId the primary key of the company 300 * @return the matching message boards thread flags, or an empty list if no matches were found 301 */ 302 @Override 303 public java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> getMBThreadFlagsByUuidAndCompanyId( 304 java.lang.String uuid, long companyId) { 305 return _mbThreadFlagLocalService.getMBThreadFlagsByUuidAndCompanyId(uuid, 306 companyId); 307 } 308 309 /** 310 * Returns a range of message boards thread flags matching the UUID and company. 311 * 312 * @param uuid the UUID of the message boards thread flags 313 * @param companyId the primary key of the company 314 * @param start the lower bound of the range of message boards thread flags 315 * @param end the upper bound of the range of message boards thread flags (not inclusive) 316 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 317 * @return the range of matching message boards thread flags, or an empty list if no matches were found 318 */ 319 @Override 320 public java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> getMBThreadFlagsByUuidAndCompanyId( 321 java.lang.String uuid, long companyId, int start, int end, 322 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 323 return _mbThreadFlagLocalService.getMBThreadFlagsByUuidAndCompanyId(uuid, 324 companyId, start, end, orderByComparator); 325 } 326 327 /** 328 * Returns the number of message boards thread flags. 329 * 330 * @return the number of message boards thread flags 331 */ 332 @Override 333 public int getMBThreadFlagsCount() { 334 return _mbThreadFlagLocalService.getMBThreadFlagsCount(); 335 } 336 337 /** 338 * Returns the OSGi service identifier. 339 * 340 * @return the OSGi service identifier 341 */ 342 @Override 343 public java.lang.String getOSGiServiceIdentifier() { 344 return _mbThreadFlagLocalService.getOSGiServiceIdentifier(); 345 } 346 347 @Override 348 public com.liferay.portal.model.PersistedModel getPersistedModel( 349 java.io.Serializable primaryKeyObj) 350 throws com.liferay.portal.kernel.exception.PortalException { 351 return _mbThreadFlagLocalService.getPersistedModel(primaryKeyObj); 352 } 353 354 @Override 355 public com.liferay.portlet.messageboards.model.MBThreadFlag getThreadFlag( 356 long userId, com.liferay.portlet.messageboards.model.MBThread thread) 357 throws com.liferay.portal.kernel.exception.PortalException { 358 return _mbThreadFlagLocalService.getThreadFlag(userId, thread); 359 } 360 361 @Override 362 public boolean hasThreadFlag(long userId, 363 com.liferay.portlet.messageboards.model.MBThread thread) 364 throws com.liferay.portal.kernel.exception.PortalException { 365 return _mbThreadFlagLocalService.hasThreadFlag(userId, thread); 366 } 367 368 /** 369 * Updates the message boards thread flag in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 370 * 371 * @param mbThreadFlag the message boards thread flag 372 * @return the message boards thread flag that was updated 373 */ 374 @Override 375 public com.liferay.portlet.messageboards.model.MBThreadFlag updateMBThreadFlag( 376 com.liferay.portlet.messageboards.model.MBThreadFlag mbThreadFlag) { 377 return _mbThreadFlagLocalService.updateMBThreadFlag(mbThreadFlag); 378 } 379 380 @Override 381 public MBThreadFlagLocalService getWrappedService() { 382 return _mbThreadFlagLocalService; 383 } 384 385 @Override 386 public void setWrappedService( 387 MBThreadFlagLocalService mbThreadFlagLocalService) { 388 _mbThreadFlagLocalService = mbThreadFlagLocalService; 389 } 390 391 private MBThreadFlagLocalService _mbThreadFlagLocalService; 392 }