001 /** 002 * Copyright (c) 2000-2010 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.tasks.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.service.ServiceContext; 022 023 import com.liferay.portlet.tasks.model.TasksProposal; 024 025 import java.util.List; 026 027 /** 028 * The persistence utility for the tasks proposal service. This utility wraps {@link TasksProposalPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 029 * 030 * <p> 031 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 032 * </p> 033 * 034 * <p> 035 * Caching information and settings can be found in <code>portal.properties</code> 036 * </p> 037 * 038 * @author Brian Wing Shun Chan 039 * @see TasksProposalPersistence 040 * @see TasksProposalPersistenceImpl 041 * @generated 042 */ 043 public class TasksProposalUtil { 044 /** 045 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 046 */ 047 public static void clearCache() { 048 getPersistence().clearCache(); 049 } 050 051 /** 052 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 053 */ 054 public static void clearCache(TasksProposal tasksProposal) { 055 getPersistence().clearCache(tasksProposal); 056 } 057 058 /** 059 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 060 */ 061 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 062 throws SystemException { 063 return getPersistence().countWithDynamicQuery(dynamicQuery); 064 } 065 066 /** 067 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 068 */ 069 public static List<TasksProposal> findWithDynamicQuery( 070 DynamicQuery dynamicQuery) throws SystemException { 071 return getPersistence().findWithDynamicQuery(dynamicQuery); 072 } 073 074 /** 075 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 076 */ 077 public static List<TasksProposal> findWithDynamicQuery( 078 DynamicQuery dynamicQuery, int start, int end) 079 throws SystemException { 080 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 081 } 082 083 /** 084 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 085 */ 086 public static List<TasksProposal> findWithDynamicQuery( 087 DynamicQuery dynamicQuery, int start, int end, 088 OrderByComparator orderByComparator) throws SystemException { 089 return getPersistence() 090 .findWithDynamicQuery(dynamicQuery, start, end, 091 orderByComparator); 092 } 093 094 /** 095 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 096 */ 097 public static TasksProposal remove(TasksProposal tasksProposal) 098 throws SystemException { 099 return getPersistence().remove(tasksProposal); 100 } 101 102 /** 103 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 104 */ 105 public static TasksProposal update(TasksProposal tasksProposal, 106 boolean merge) throws SystemException { 107 return getPersistence().update(tasksProposal, merge); 108 } 109 110 /** 111 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 112 */ 113 public static TasksProposal update(TasksProposal tasksProposal, 114 boolean merge, ServiceContext serviceContext) throws SystemException { 115 return getPersistence().update(tasksProposal, merge, serviceContext); 116 } 117 118 /** 119 * Caches the tasks proposal in the entity cache if it is enabled. 120 * 121 * @param tasksProposal the tasks proposal to cache 122 */ 123 public static void cacheResult( 124 com.liferay.portlet.tasks.model.TasksProposal tasksProposal) { 125 getPersistence().cacheResult(tasksProposal); 126 } 127 128 /** 129 * Caches the tasks proposals in the entity cache if it is enabled. 130 * 131 * @param tasksProposals the tasks proposals to cache 132 */ 133 public static void cacheResult( 134 java.util.List<com.liferay.portlet.tasks.model.TasksProposal> tasksProposals) { 135 getPersistence().cacheResult(tasksProposals); 136 } 137 138 /** 139 * Creates a new tasks proposal with the primary key. Does not add the tasks proposal to the database. 140 * 141 * @param proposalId the primary key for the new tasks proposal 142 * @return the new tasks proposal 143 */ 144 public static com.liferay.portlet.tasks.model.TasksProposal create( 145 long proposalId) { 146 return getPersistence().create(proposalId); 147 } 148 149 /** 150 * Removes the tasks proposal with the primary key from the database. Also notifies the appropriate model listeners. 151 * 152 * @param proposalId the primary key of the tasks proposal to remove 153 * @return the tasks proposal that was removed 154 * @throws com.liferay.portlet.tasks.NoSuchProposalException if a tasks proposal with the primary key could not be found 155 * @throws SystemException if a system exception occurred 156 */ 157 public static com.liferay.portlet.tasks.model.TasksProposal remove( 158 long proposalId) 159 throws com.liferay.portal.kernel.exception.SystemException, 160 com.liferay.portlet.tasks.NoSuchProposalException { 161 return getPersistence().remove(proposalId); 162 } 163 164 public static com.liferay.portlet.tasks.model.TasksProposal updateImpl( 165 com.liferay.portlet.tasks.model.TasksProposal tasksProposal, 166 boolean merge) 167 throws com.liferay.portal.kernel.exception.SystemException { 168 return getPersistence().updateImpl(tasksProposal, merge); 169 } 170 171 /** 172 * Finds the tasks proposal with the primary key or throws a {@link com.liferay.portlet.tasks.NoSuchProposalException} if it could not be found. 173 * 174 * @param proposalId the primary key of the tasks proposal to find 175 * @return the tasks proposal 176 * @throws com.liferay.portlet.tasks.NoSuchProposalException if a tasks proposal with the primary key could not be found 177 * @throws SystemException if a system exception occurred 178 */ 179 public static com.liferay.portlet.tasks.model.TasksProposal findByPrimaryKey( 180 long proposalId) 181 throws com.liferay.portal.kernel.exception.SystemException, 182 com.liferay.portlet.tasks.NoSuchProposalException { 183 return getPersistence().findByPrimaryKey(proposalId); 184 } 185 186 /** 187 * Finds the tasks proposal with the primary key or returns <code>null</code> if it could not be found. 188 * 189 * @param proposalId the primary key of the tasks proposal to find 190 * @return the tasks proposal, or <code>null</code> if a tasks proposal with the primary key could not be found 191 * @throws SystemException if a system exception occurred 192 */ 193 public static com.liferay.portlet.tasks.model.TasksProposal fetchByPrimaryKey( 194 long proposalId) 195 throws com.liferay.portal.kernel.exception.SystemException { 196 return getPersistence().fetchByPrimaryKey(proposalId); 197 } 198 199 /** 200 * Finds all the tasks proposals where groupId = ?. 201 * 202 * @param groupId the group id to search with 203 * @return the matching tasks proposals 204 * @throws SystemException if a system exception occurred 205 */ 206 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> findByGroupId( 207 long groupId) 208 throws com.liferay.portal.kernel.exception.SystemException { 209 return getPersistence().findByGroupId(groupId); 210 } 211 212 /** 213 * Finds a range of all the tasks proposals where groupId = ?. 214 * 215 * <p> 216 * 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. 217 * </p> 218 * 219 * @param groupId the group id to search with 220 * @param start the lower bound of the range of tasks proposals to return 221 * @param end the upper bound of the range of tasks proposals to return (not inclusive) 222 * @return the range of matching tasks proposals 223 * @throws SystemException if a system exception occurred 224 */ 225 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> findByGroupId( 226 long groupId, int start, int end) 227 throws com.liferay.portal.kernel.exception.SystemException { 228 return getPersistence().findByGroupId(groupId, start, end); 229 } 230 231 /** 232 * Finds an ordered range of all the tasks proposals where groupId = ?. 233 * 234 * <p> 235 * 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. 236 * </p> 237 * 238 * @param groupId the group id to search with 239 * @param start the lower bound of the range of tasks proposals to return 240 * @param end the upper bound of the range of tasks proposals to return (not inclusive) 241 * @param orderByComparator the comparator to order the results by 242 * @return the ordered range of matching tasks proposals 243 * @throws SystemException if a system exception occurred 244 */ 245 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> findByGroupId( 246 long groupId, int start, int end, 247 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 248 throws com.liferay.portal.kernel.exception.SystemException { 249 return getPersistence() 250 .findByGroupId(groupId, start, end, orderByComparator); 251 } 252 253 /** 254 * Finds the first tasks proposal in the ordered set where groupId = ?. 255 * 256 * <p> 257 * 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. 258 * </p> 259 * 260 * @param groupId the group id to search with 261 * @param orderByComparator the comparator to order the set by 262 * @return the first matching tasks proposal 263 * @throws com.liferay.portlet.tasks.NoSuchProposalException if a matching tasks proposal could not be found 264 * @throws SystemException if a system exception occurred 265 */ 266 public static com.liferay.portlet.tasks.model.TasksProposal findByGroupId_First( 267 long groupId, 268 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 269 throws com.liferay.portal.kernel.exception.SystemException, 270 com.liferay.portlet.tasks.NoSuchProposalException { 271 return getPersistence().findByGroupId_First(groupId, orderByComparator); 272 } 273 274 /** 275 * Finds the last tasks proposal in the ordered set where groupId = ?. 276 * 277 * <p> 278 * 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. 279 * </p> 280 * 281 * @param groupId the group id to search with 282 * @param orderByComparator the comparator to order the set by 283 * @return the last matching tasks proposal 284 * @throws com.liferay.portlet.tasks.NoSuchProposalException if a matching tasks proposal could not be found 285 * @throws SystemException if a system exception occurred 286 */ 287 public static com.liferay.portlet.tasks.model.TasksProposal findByGroupId_Last( 288 long groupId, 289 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 290 throws com.liferay.portal.kernel.exception.SystemException, 291 com.liferay.portlet.tasks.NoSuchProposalException { 292 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 293 } 294 295 /** 296 * Finds the tasks proposals before and after the current tasks proposal in the ordered set where groupId = ?. 297 * 298 * <p> 299 * 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. 300 * </p> 301 * 302 * @param proposalId the primary key of the current tasks proposal 303 * @param groupId the group id to search with 304 * @param orderByComparator the comparator to order the set by 305 * @return the previous, current, and next tasks proposal 306 * @throws com.liferay.portlet.tasks.NoSuchProposalException if a tasks proposal with the primary key could not be found 307 * @throws SystemException if a system exception occurred 308 */ 309 public static com.liferay.portlet.tasks.model.TasksProposal[] findByGroupId_PrevAndNext( 310 long proposalId, long groupId, 311 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 312 throws com.liferay.portal.kernel.exception.SystemException, 313 com.liferay.portlet.tasks.NoSuchProposalException { 314 return getPersistence() 315 .findByGroupId_PrevAndNext(proposalId, groupId, 316 orderByComparator); 317 } 318 319 /** 320 * Filters by the user's permissions and finds all the tasks proposals where groupId = ?. 321 * 322 * @param groupId the group id to search with 323 * @return the matching tasks proposals that the user has permission to view 324 * @throws SystemException if a system exception occurred 325 */ 326 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> filterFindByGroupId( 327 long groupId) 328 throws com.liferay.portal.kernel.exception.SystemException { 329 return getPersistence().filterFindByGroupId(groupId); 330 } 331 332 /** 333 * Filters by the user's permissions and finds a range of all the tasks proposals where groupId = ?. 334 * 335 * <p> 336 * 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. 337 * </p> 338 * 339 * @param groupId the group id to search with 340 * @param start the lower bound of the range of tasks proposals to return 341 * @param end the upper bound of the range of tasks proposals to return (not inclusive) 342 * @return the range of matching tasks proposals that the user has permission to view 343 * @throws SystemException if a system exception occurred 344 */ 345 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> filterFindByGroupId( 346 long groupId, int start, int end) 347 throws com.liferay.portal.kernel.exception.SystemException { 348 return getPersistence().filterFindByGroupId(groupId, start, end); 349 } 350 351 /** 352 * Filters by the user's permissions and finds an ordered range of all the tasks proposals where groupId = ?. 353 * 354 * <p> 355 * 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. 356 * </p> 357 * 358 * @param groupId the group id to search with 359 * @param start the lower bound of the range of tasks proposals to return 360 * @param end the upper bound of the range of tasks proposals to return (not inclusive) 361 * @param orderByComparator the comparator to order the results by 362 * @return the ordered range of matching tasks proposals that the user has permission to view 363 * @throws SystemException if a system exception occurred 364 */ 365 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> filterFindByGroupId( 366 long groupId, int start, int end, 367 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 368 throws com.liferay.portal.kernel.exception.SystemException { 369 return getPersistence() 370 .filterFindByGroupId(groupId, start, end, orderByComparator); 371 } 372 373 /** 374 * Finds all the tasks proposals where groupId = ? and userId = ?. 375 * 376 * @param groupId the group id to search with 377 * @param userId the user id to search with 378 * @return the matching tasks proposals 379 * @throws SystemException if a system exception occurred 380 */ 381 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> findByG_U( 382 long groupId, long userId) 383 throws com.liferay.portal.kernel.exception.SystemException { 384 return getPersistence().findByG_U(groupId, userId); 385 } 386 387 /** 388 * Finds a range of all the tasks proposals where groupId = ? and userId = ?. 389 * 390 * <p> 391 * 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. 392 * </p> 393 * 394 * @param groupId the group id to search with 395 * @param userId the user id to search with 396 * @param start the lower bound of the range of tasks proposals to return 397 * @param end the upper bound of the range of tasks proposals to return (not inclusive) 398 * @return the range of matching tasks proposals 399 * @throws SystemException if a system exception occurred 400 */ 401 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> findByG_U( 402 long groupId, long userId, int start, int end) 403 throws com.liferay.portal.kernel.exception.SystemException { 404 return getPersistence().findByG_U(groupId, userId, start, end); 405 } 406 407 /** 408 * Finds an ordered range of all the tasks proposals where groupId = ? and userId = ?. 409 * 410 * <p> 411 * 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. 412 * </p> 413 * 414 * @param groupId the group id to search with 415 * @param userId the user id to search with 416 * @param start the lower bound of the range of tasks proposals to return 417 * @param end the upper bound of the range of tasks proposals to return (not inclusive) 418 * @param orderByComparator the comparator to order the results by 419 * @return the ordered range of matching tasks proposals 420 * @throws SystemException if a system exception occurred 421 */ 422 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> findByG_U( 423 long groupId, long userId, int start, int end, 424 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 425 throws com.liferay.portal.kernel.exception.SystemException { 426 return getPersistence() 427 .findByG_U(groupId, userId, start, end, orderByComparator); 428 } 429 430 /** 431 * Finds the first tasks proposal in the ordered set where groupId = ? and userId = ?. 432 * 433 * <p> 434 * 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. 435 * </p> 436 * 437 * @param groupId the group id to search with 438 * @param userId the user id to search with 439 * @param orderByComparator the comparator to order the set by 440 * @return the first matching tasks proposal 441 * @throws com.liferay.portlet.tasks.NoSuchProposalException if a matching tasks proposal could not be found 442 * @throws SystemException if a system exception occurred 443 */ 444 public static com.liferay.portlet.tasks.model.TasksProposal findByG_U_First( 445 long groupId, long userId, 446 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 447 throws com.liferay.portal.kernel.exception.SystemException, 448 com.liferay.portlet.tasks.NoSuchProposalException { 449 return getPersistence() 450 .findByG_U_First(groupId, userId, orderByComparator); 451 } 452 453 /** 454 * Finds the last tasks proposal in the ordered set where groupId = ? and userId = ?. 455 * 456 * <p> 457 * 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. 458 * </p> 459 * 460 * @param groupId the group id to search with 461 * @param userId the user id to search with 462 * @param orderByComparator the comparator to order the set by 463 * @return the last matching tasks proposal 464 * @throws com.liferay.portlet.tasks.NoSuchProposalException if a matching tasks proposal could not be found 465 * @throws SystemException if a system exception occurred 466 */ 467 public static com.liferay.portlet.tasks.model.TasksProposal findByG_U_Last( 468 long groupId, long userId, 469 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 470 throws com.liferay.portal.kernel.exception.SystemException, 471 com.liferay.portlet.tasks.NoSuchProposalException { 472 return getPersistence() 473 .findByG_U_Last(groupId, userId, orderByComparator); 474 } 475 476 /** 477 * Finds the tasks proposals before and after the current tasks proposal in the ordered set where groupId = ? and userId = ?. 478 * 479 * <p> 480 * 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. 481 * </p> 482 * 483 * @param proposalId the primary key of the current tasks proposal 484 * @param groupId the group id to search with 485 * @param userId the user id to search with 486 * @param orderByComparator the comparator to order the set by 487 * @return the previous, current, and next tasks proposal 488 * @throws com.liferay.portlet.tasks.NoSuchProposalException if a tasks proposal with the primary key could not be found 489 * @throws SystemException if a system exception occurred 490 */ 491 public static com.liferay.portlet.tasks.model.TasksProposal[] findByG_U_PrevAndNext( 492 long proposalId, long groupId, long userId, 493 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 494 throws com.liferay.portal.kernel.exception.SystemException, 495 com.liferay.portlet.tasks.NoSuchProposalException { 496 return getPersistence() 497 .findByG_U_PrevAndNext(proposalId, groupId, userId, 498 orderByComparator); 499 } 500 501 /** 502 * Filters by the user's permissions and finds all the tasks proposals where groupId = ? and userId = ?. 503 * 504 * @param groupId the group id to search with 505 * @param userId the user id to search with 506 * @return the matching tasks proposals that the user has permission to view 507 * @throws SystemException if a system exception occurred 508 */ 509 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> filterFindByG_U( 510 long groupId, long userId) 511 throws com.liferay.portal.kernel.exception.SystemException { 512 return getPersistence().filterFindByG_U(groupId, userId); 513 } 514 515 /** 516 * Filters by the user's permissions and finds a range of all the tasks proposals where groupId = ? and userId = ?. 517 * 518 * <p> 519 * 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. 520 * </p> 521 * 522 * @param groupId the group id to search with 523 * @param userId the user id to search with 524 * @param start the lower bound of the range of tasks proposals to return 525 * @param end the upper bound of the range of tasks proposals to return (not inclusive) 526 * @return the range of matching tasks proposals that the user has permission to view 527 * @throws SystemException if a system exception occurred 528 */ 529 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> filterFindByG_U( 530 long groupId, long userId, int start, int end) 531 throws com.liferay.portal.kernel.exception.SystemException { 532 return getPersistence().filterFindByG_U(groupId, userId, start, end); 533 } 534 535 /** 536 * Filters by the user's permissions and finds an ordered range of all the tasks proposals where groupId = ? and userId = ?. 537 * 538 * <p> 539 * 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. 540 * </p> 541 * 542 * @param groupId the group id to search with 543 * @param userId the user id to search with 544 * @param start the lower bound of the range of tasks proposals to return 545 * @param end the upper bound of the range of tasks proposals to return (not inclusive) 546 * @param orderByComparator the comparator to order the results by 547 * @return the ordered range of matching tasks proposals that the user has permission to view 548 * @throws SystemException if a system exception occurred 549 */ 550 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> filterFindByG_U( 551 long groupId, long userId, int start, int end, 552 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 553 throws com.liferay.portal.kernel.exception.SystemException { 554 return getPersistence() 555 .filterFindByG_U(groupId, userId, start, end, 556 orderByComparator); 557 } 558 559 /** 560 * Finds the tasks proposal where classNameId = ? and classPK = ? or throws a {@link com.liferay.portlet.tasks.NoSuchProposalException} if it could not be found. 561 * 562 * @param classNameId the class name id to search with 563 * @param classPK the class p k to search with 564 * @return the matching tasks proposal 565 * @throws com.liferay.portlet.tasks.NoSuchProposalException if a matching tasks proposal could not be found 566 * @throws SystemException if a system exception occurred 567 */ 568 public static com.liferay.portlet.tasks.model.TasksProposal findByC_C( 569 long classNameId, java.lang.String classPK) 570 throws com.liferay.portal.kernel.exception.SystemException, 571 com.liferay.portlet.tasks.NoSuchProposalException { 572 return getPersistence().findByC_C(classNameId, classPK); 573 } 574 575 /** 576 * Finds the tasks proposal where classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 577 * 578 * @param classNameId the class name id to search with 579 * @param classPK the class p k to search with 580 * @return the matching tasks proposal, or <code>null</code> if a matching tasks proposal could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public static com.liferay.portlet.tasks.model.TasksProposal fetchByC_C( 584 long classNameId, java.lang.String classPK) 585 throws com.liferay.portal.kernel.exception.SystemException { 586 return getPersistence().fetchByC_C(classNameId, classPK); 587 } 588 589 /** 590 * Finds the tasks proposal where classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 591 * 592 * @param classNameId the class name id to search with 593 * @param classPK the class p k to search with 594 * @return the matching tasks proposal, or <code>null</code> if a matching tasks proposal could not be found 595 * @throws SystemException if a system exception occurred 596 */ 597 public static com.liferay.portlet.tasks.model.TasksProposal fetchByC_C( 598 long classNameId, java.lang.String classPK, boolean retrieveFromCache) 599 throws com.liferay.portal.kernel.exception.SystemException { 600 return getPersistence() 601 .fetchByC_C(classNameId, classPK, retrieveFromCache); 602 } 603 604 /** 605 * Finds all the tasks proposals. 606 * 607 * @return the tasks proposals 608 * @throws SystemException if a system exception occurred 609 */ 610 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> findAll() 611 throws com.liferay.portal.kernel.exception.SystemException { 612 return getPersistence().findAll(); 613 } 614 615 /** 616 * Finds a range of all the tasks proposals. 617 * 618 * <p> 619 * 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. 620 * </p> 621 * 622 * @param start the lower bound of the range of tasks proposals to return 623 * @param end the upper bound of the range of tasks proposals to return (not inclusive) 624 * @return the range of tasks proposals 625 * @throws SystemException if a system exception occurred 626 */ 627 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> findAll( 628 int start, int end) 629 throws com.liferay.portal.kernel.exception.SystemException { 630 return getPersistence().findAll(start, end); 631 } 632 633 /** 634 * Finds an ordered range of all the tasks proposals. 635 * 636 * <p> 637 * 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. 638 * </p> 639 * 640 * @param start the lower bound of the range of tasks proposals to return 641 * @param end the upper bound of the range of tasks proposals to return (not inclusive) 642 * @param orderByComparator the comparator to order the results by 643 * @return the ordered range of tasks proposals 644 * @throws SystemException if a system exception occurred 645 */ 646 public static java.util.List<com.liferay.portlet.tasks.model.TasksProposal> findAll( 647 int start, int end, 648 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 649 throws com.liferay.portal.kernel.exception.SystemException { 650 return getPersistence().findAll(start, end, orderByComparator); 651 } 652 653 /** 654 * Removes all the tasks proposals where groupId = ? from the database. 655 * 656 * @param groupId the group id to search with 657 * @throws SystemException if a system exception occurred 658 */ 659 public static void removeByGroupId(long groupId) 660 throws com.liferay.portal.kernel.exception.SystemException { 661 getPersistence().removeByGroupId(groupId); 662 } 663 664 /** 665 * Removes all the tasks proposals where groupId = ? and userId = ? from the database. 666 * 667 * @param groupId the group id to search with 668 * @param userId the user id to search with 669 * @throws SystemException if a system exception occurred 670 */ 671 public static void removeByG_U(long groupId, long userId) 672 throws com.liferay.portal.kernel.exception.SystemException { 673 getPersistence().removeByG_U(groupId, userId); 674 } 675 676 /** 677 * Removes the tasks proposal where classNameId = ? and classPK = ? from the database. 678 * 679 * @param classNameId the class name id to search with 680 * @param classPK the class p k to search with 681 * @throws SystemException if a system exception occurred 682 */ 683 public static void removeByC_C(long classNameId, java.lang.String classPK) 684 throws com.liferay.portal.kernel.exception.SystemException, 685 com.liferay.portlet.tasks.NoSuchProposalException { 686 getPersistence().removeByC_C(classNameId, classPK); 687 } 688 689 /** 690 * Removes all the tasks proposals from the database. 691 * 692 * @throws SystemException if a system exception occurred 693 */ 694 public static void removeAll() 695 throws com.liferay.portal.kernel.exception.SystemException { 696 getPersistence().removeAll(); 697 } 698 699 /** 700 * Counts all the tasks proposals where groupId = ?. 701 * 702 * @param groupId the group id to search with 703 * @return the number of matching tasks proposals 704 * @throws SystemException if a system exception occurred 705 */ 706 public static int countByGroupId(long groupId) 707 throws com.liferay.portal.kernel.exception.SystemException { 708 return getPersistence().countByGroupId(groupId); 709 } 710 711 /** 712 * Filters by the user's permissions and counts all the tasks proposals where groupId = ?. 713 * 714 * @param groupId the group id to search with 715 * @return the number of matching tasks proposals that the user has permission to view 716 * @throws SystemException if a system exception occurred 717 */ 718 public static int filterCountByGroupId(long groupId) 719 throws com.liferay.portal.kernel.exception.SystemException { 720 return getPersistence().filterCountByGroupId(groupId); 721 } 722 723 /** 724 * Counts all the tasks proposals where groupId = ? and userId = ?. 725 * 726 * @param groupId the group id to search with 727 * @param userId the user id to search with 728 * @return the number of matching tasks proposals 729 * @throws SystemException if a system exception occurred 730 */ 731 public static int countByG_U(long groupId, long userId) 732 throws com.liferay.portal.kernel.exception.SystemException { 733 return getPersistence().countByG_U(groupId, userId); 734 } 735 736 /** 737 * Filters by the user's permissions and counts all the tasks proposals where groupId = ? and userId = ?. 738 * 739 * @param groupId the group id to search with 740 * @param userId the user id to search with 741 * @return the number of matching tasks proposals that the user has permission to view 742 * @throws SystemException if a system exception occurred 743 */ 744 public static int filterCountByG_U(long groupId, long userId) 745 throws com.liferay.portal.kernel.exception.SystemException { 746 return getPersistence().filterCountByG_U(groupId, userId); 747 } 748 749 /** 750 * Counts all the tasks proposals where classNameId = ? and classPK = ?. 751 * 752 * @param classNameId the class name id to search with 753 * @param classPK the class p k to search with 754 * @return the number of matching tasks proposals 755 * @throws SystemException if a system exception occurred 756 */ 757 public static int countByC_C(long classNameId, java.lang.String classPK) 758 throws com.liferay.portal.kernel.exception.SystemException { 759 return getPersistence().countByC_C(classNameId, classPK); 760 } 761 762 /** 763 * Counts all the tasks proposals. 764 * 765 * @return the number of tasks proposals 766 * @throws SystemException if a system exception occurred 767 */ 768 public static int countAll() 769 throws com.liferay.portal.kernel.exception.SystemException { 770 return getPersistence().countAll(); 771 } 772 773 public static TasksProposalPersistence getPersistence() { 774 if (_persistence == null) { 775 _persistence = (TasksProposalPersistence)PortalBeanLocatorUtil.locate(TasksProposalPersistence.class.getName()); 776 } 777 778 return _persistence; 779 } 780 781 public void setPersistence(TasksProposalPersistence persistence) { 782 _persistence = persistence; 783 } 784 785 private static TasksProposalPersistence _persistence; 786 }