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