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.message.boards.kernel.service; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.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 @Override 037 public boolean hasThreadFlag(long userId, 038 com.liferay.message.boards.kernel.model.MBThread thread) 039 throws com.liferay.portal.kernel.exception.PortalException { 040 return _mbThreadFlagLocalService.hasThreadFlag(userId, thread); 041 } 042 043 /** 044 * Adds the message boards thread flag to the database. Also notifies the appropriate model listeners. 045 * 046 * @param mbThreadFlag the message boards thread flag 047 * @return the message boards thread flag that was added 048 */ 049 @Override 050 public com.liferay.message.boards.kernel.model.MBThreadFlag addMBThreadFlag( 051 com.liferay.message.boards.kernel.model.MBThreadFlag mbThreadFlag) { 052 return _mbThreadFlagLocalService.addMBThreadFlag(mbThreadFlag); 053 } 054 055 @Override 056 public com.liferay.message.boards.kernel.model.MBThreadFlag addThreadFlag( 057 long userId, com.liferay.message.boards.kernel.model.MBThread thread, 058 com.liferay.portal.kernel.service.ServiceContext serviceContext) 059 throws com.liferay.portal.kernel.exception.PortalException { 060 return _mbThreadFlagLocalService.addThreadFlag(userId, thread, 061 serviceContext); 062 } 063 064 /** 065 * Creates a new message boards thread flag with the primary key. Does not add the message boards thread flag to the database. 066 * 067 * @param threadFlagId the primary key for the new message boards thread flag 068 * @return the new message boards thread flag 069 */ 070 @Override 071 public com.liferay.message.boards.kernel.model.MBThreadFlag createMBThreadFlag( 072 long threadFlagId) { 073 return _mbThreadFlagLocalService.createMBThreadFlag(threadFlagId); 074 } 075 076 /** 077 * Deletes the message boards thread flag from the database. Also notifies the appropriate model listeners. 078 * 079 * @param mbThreadFlag the message boards thread flag 080 * @return the message boards thread flag that was removed 081 */ 082 @Override 083 public com.liferay.message.boards.kernel.model.MBThreadFlag deleteMBThreadFlag( 084 com.liferay.message.boards.kernel.model.MBThreadFlag mbThreadFlag) { 085 return _mbThreadFlagLocalService.deleteMBThreadFlag(mbThreadFlag); 086 } 087 088 /** 089 * Deletes the message boards thread flag with the primary key from the database. Also notifies the appropriate model listeners. 090 * 091 * @param threadFlagId the primary key of the message boards thread flag 092 * @return the message boards thread flag that was removed 093 * @throws PortalException if a message boards thread flag with the primary key could not be found 094 */ 095 @Override 096 public com.liferay.message.boards.kernel.model.MBThreadFlag deleteMBThreadFlag( 097 long threadFlagId) 098 throws com.liferay.portal.kernel.exception.PortalException { 099 return _mbThreadFlagLocalService.deleteMBThreadFlag(threadFlagId); 100 } 101 102 @Override 103 public com.liferay.message.boards.kernel.model.MBThreadFlag fetchMBThreadFlag( 104 long threadFlagId) { 105 return _mbThreadFlagLocalService.fetchMBThreadFlag(threadFlagId); 106 } 107 108 /** 109 * Returns the message boards thread flag matching the UUID and group. 110 * 111 * @param uuid the message boards thread flag's UUID 112 * @param groupId the primary key of the group 113 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 114 */ 115 @Override 116 public com.liferay.message.boards.kernel.model.MBThreadFlag fetchMBThreadFlagByUuidAndGroupId( 117 java.lang.String uuid, long groupId) { 118 return _mbThreadFlagLocalService.fetchMBThreadFlagByUuidAndGroupId(uuid, 119 groupId); 120 } 121 122 /** 123 * Returns the message boards thread flag with the primary key. 124 * 125 * @param threadFlagId the primary key of the message boards thread flag 126 * @return the message boards thread flag 127 * @throws PortalException if a message boards thread flag with the primary key could not be found 128 */ 129 @Override 130 public com.liferay.message.boards.kernel.model.MBThreadFlag getMBThreadFlag( 131 long threadFlagId) 132 throws com.liferay.portal.kernel.exception.PortalException { 133 return _mbThreadFlagLocalService.getMBThreadFlag(threadFlagId); 134 } 135 136 /** 137 * Returns the message boards thread flag matching the UUID and group. 138 * 139 * @param uuid the message boards thread flag's UUID 140 * @param groupId the primary key of the group 141 * @return the matching message boards thread flag 142 * @throws PortalException if a matching message boards thread flag could not be found 143 */ 144 @Override 145 public com.liferay.message.boards.kernel.model.MBThreadFlag getMBThreadFlagByUuidAndGroupId( 146 java.lang.String uuid, long groupId) 147 throws com.liferay.portal.kernel.exception.PortalException { 148 return _mbThreadFlagLocalService.getMBThreadFlagByUuidAndGroupId(uuid, 149 groupId); 150 } 151 152 @Override 153 public com.liferay.message.boards.kernel.model.MBThreadFlag getThreadFlag( 154 long userId, com.liferay.message.boards.kernel.model.MBThread thread) 155 throws com.liferay.portal.kernel.exception.PortalException { 156 return _mbThreadFlagLocalService.getThreadFlag(userId, thread); 157 } 158 159 /** 160 * Updates the message boards thread flag in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 161 * 162 * @param mbThreadFlag the message boards thread flag 163 * @return the message boards thread flag that was updated 164 */ 165 @Override 166 public com.liferay.message.boards.kernel.model.MBThreadFlag updateMBThreadFlag( 167 com.liferay.message.boards.kernel.model.MBThreadFlag mbThreadFlag) { 168 return _mbThreadFlagLocalService.updateMBThreadFlag(mbThreadFlag); 169 } 170 171 @Override 172 public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() { 173 return _mbThreadFlagLocalService.getActionableDynamicQuery(); 174 } 175 176 @Override 177 public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() { 178 return _mbThreadFlagLocalService.dynamicQuery(); 179 } 180 181 @Override 182 public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery( 183 com.liferay.exportimport.kernel.lar.PortletDataContext portletDataContext) { 184 return _mbThreadFlagLocalService.getExportActionableDynamicQuery(portletDataContext); 185 } 186 187 @Override 188 public com.liferay.portal.kernel.dao.orm.IndexableActionableDynamicQuery getIndexableActionableDynamicQuery() { 189 return _mbThreadFlagLocalService.getIndexableActionableDynamicQuery(); 190 } 191 192 /** 193 * @throws PortalException 194 */ 195 @Override 196 public com.liferay.portal.kernel.model.PersistedModel deletePersistedModel( 197 com.liferay.portal.kernel.model.PersistedModel persistedModel) 198 throws com.liferay.portal.kernel.exception.PortalException { 199 return _mbThreadFlagLocalService.deletePersistedModel(persistedModel); 200 } 201 202 @Override 203 public com.liferay.portal.kernel.model.PersistedModel getPersistedModel( 204 java.io.Serializable primaryKeyObj) 205 throws com.liferay.portal.kernel.exception.PortalException { 206 return _mbThreadFlagLocalService.getPersistedModel(primaryKeyObj); 207 } 208 209 /** 210 * Returns the number of message boards thread flags. 211 * 212 * @return the number of message boards thread flags 213 */ 214 @Override 215 public int getMBThreadFlagsCount() { 216 return _mbThreadFlagLocalService.getMBThreadFlagsCount(); 217 } 218 219 /** 220 * Returns the OSGi service identifier. 221 * 222 * @return the OSGi service identifier 223 */ 224 @Override 225 public java.lang.String getOSGiServiceIdentifier() { 226 return _mbThreadFlagLocalService.getOSGiServiceIdentifier(); 227 } 228 229 /** 230 * Performs a dynamic query on the database and returns the matching rows. 231 * 232 * @param dynamicQuery the dynamic query 233 * @return the matching rows 234 */ 235 @Override 236 public <T> java.util.List<T> dynamicQuery( 237 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 238 return _mbThreadFlagLocalService.dynamicQuery(dynamicQuery); 239 } 240 241 /** 242 * Performs a dynamic query on the database and returns a range of the matching rows. 243 * 244 * <p> 245 * 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. 246 * </p> 247 * 248 * @param dynamicQuery the dynamic query 249 * @param start the lower bound of the range of model instances 250 * @param end the upper bound of the range of model instances (not inclusive) 251 * @return the range of matching rows 252 */ 253 @Override 254 public <T> java.util.List<T> dynamicQuery( 255 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 256 int end) { 257 return _mbThreadFlagLocalService.dynamicQuery(dynamicQuery, start, end); 258 } 259 260 /** 261 * Performs a dynamic query on the database and returns an ordered range of the matching rows. 262 * 263 * <p> 264 * 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. 265 * </p> 266 * 267 * @param dynamicQuery the dynamic query 268 * @param start the lower bound of the range of model instances 269 * @param end the upper bound of the range of model instances (not inclusive) 270 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 271 * @return the ordered range of matching rows 272 */ 273 @Override 274 public <T> java.util.List<T> dynamicQuery( 275 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 276 int end, 277 com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) { 278 return _mbThreadFlagLocalService.dynamicQuery(dynamicQuery, start, end, 279 orderByComparator); 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.message.boards.kernel.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.message.boards.kernel.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.message.boards.kernel.model.MBThreadFlag> getMBThreadFlagsByUuidAndCompanyId( 325 java.lang.String uuid, long companyId, int start, int end, 326 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.message.boards.kernel.model.MBThreadFlag> orderByComparator) { 327 return _mbThreadFlagLocalService.getMBThreadFlagsByUuidAndCompanyId(uuid, 328 companyId, start, end, orderByComparator); 329 } 330 331 /** 332 * Returns the number of rows matching the dynamic query. 333 * 334 * @param dynamicQuery the dynamic query 335 * @return the number of rows matching the dynamic query 336 */ 337 @Override 338 public long dynamicQueryCount( 339 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 340 return _mbThreadFlagLocalService.dynamicQueryCount(dynamicQuery); 341 } 342 343 /** 344 * Returns the number of rows matching the dynamic query. 345 * 346 * @param dynamicQuery the dynamic query 347 * @param projection the projection to apply to the query 348 * @return the number of rows matching the dynamic query 349 */ 350 @Override 351 public long dynamicQueryCount( 352 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, 353 com.liferay.portal.kernel.dao.orm.Projection projection) { 354 return _mbThreadFlagLocalService.dynamicQueryCount(dynamicQuery, 355 projection); 356 } 357 358 @Override 359 public void deleteThreadFlag( 360 com.liferay.message.boards.kernel.model.MBThreadFlag threadFlag) { 361 _mbThreadFlagLocalService.deleteThreadFlag(threadFlag); 362 } 363 364 @Override 365 public void deleteThreadFlag(long threadFlagId) 366 throws com.liferay.portal.kernel.exception.PortalException { 367 _mbThreadFlagLocalService.deleteThreadFlag(threadFlagId); 368 } 369 370 @Override 371 public void deleteThreadFlagsByThreadId(long threadId) { 372 _mbThreadFlagLocalService.deleteThreadFlagsByThreadId(threadId); 373 } 374 375 @Override 376 public void deleteThreadFlagsByUserId(long userId) { 377 _mbThreadFlagLocalService.deleteThreadFlagsByUserId(userId); 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 }