001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.exportimport.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.service.ServiceContext; 024 025 import com.liferay.portlet.exportimport.model.ExportImportConfiguration; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the export import configuration service. This utility wraps {@link com.liferay.portlet.exportimport.service.persistence.impl.ExportImportConfigurationPersistenceImpl} 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. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see ExportImportConfigurationPersistence 038 * @see com.liferay.portlet.exportimport.service.persistence.impl.ExportImportConfigurationPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class ExportImportConfigurationUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache( 060 ExportImportConfiguration exportImportConfiguration) { 061 getPersistence().clearCache(exportImportConfiguration); 062 } 063 064 /** 065 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 066 */ 067 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 068 return getPersistence().countWithDynamicQuery(dynamicQuery); 069 } 070 071 /** 072 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 073 */ 074 public static List<ExportImportConfiguration> findWithDynamicQuery( 075 DynamicQuery dynamicQuery) { 076 return getPersistence().findWithDynamicQuery(dynamicQuery); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 081 */ 082 public static List<ExportImportConfiguration> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end) { 084 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 085 } 086 087 /** 088 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 089 */ 090 public static List<ExportImportConfiguration> findWithDynamicQuery( 091 DynamicQuery dynamicQuery, int start, int end, 092 OrderByComparator<ExportImportConfiguration> orderByComparator) { 093 return getPersistence() 094 .findWithDynamicQuery(dynamicQuery, start, end, 095 orderByComparator); 096 } 097 098 /** 099 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 100 */ 101 public static ExportImportConfiguration update( 102 ExportImportConfiguration exportImportConfiguration) { 103 return getPersistence().update(exportImportConfiguration); 104 } 105 106 /** 107 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 108 */ 109 public static ExportImportConfiguration update( 110 ExportImportConfiguration exportImportConfiguration, 111 ServiceContext serviceContext) { 112 return getPersistence().update(exportImportConfiguration, serviceContext); 113 } 114 115 /** 116 * Returns all the export import configurations where groupId = ?. 117 * 118 * @param groupId the group ID 119 * @return the matching export import configurations 120 */ 121 public static List<ExportImportConfiguration> findByGroupId(long groupId) { 122 return getPersistence().findByGroupId(groupId); 123 } 124 125 /** 126 * Returns a range of all the export import configurations where groupId = ?. 127 * 128 * <p> 129 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 130 * </p> 131 * 132 * @param groupId the group ID 133 * @param start the lower bound of the range of export import configurations 134 * @param end the upper bound of the range of export import configurations (not inclusive) 135 * @return the range of matching export import configurations 136 */ 137 public static List<ExportImportConfiguration> findByGroupId(long groupId, 138 int start, int end) { 139 return getPersistence().findByGroupId(groupId, start, end); 140 } 141 142 /** 143 * Returns an ordered range of all the export import configurations where groupId = ?. 144 * 145 * <p> 146 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 147 * </p> 148 * 149 * @param groupId the group ID 150 * @param start the lower bound of the range of export import configurations 151 * @param end the upper bound of the range of export import configurations (not inclusive) 152 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 153 * @return the ordered range of matching export import configurations 154 */ 155 public static List<ExportImportConfiguration> findByGroupId(long groupId, 156 int start, int end, 157 OrderByComparator<ExportImportConfiguration> orderByComparator) { 158 return getPersistence() 159 .findByGroupId(groupId, start, end, orderByComparator); 160 } 161 162 /** 163 * Returns the first export import configuration in the ordered set where groupId = ?. 164 * 165 * @param groupId the group ID 166 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 167 * @return the first matching export import configuration 168 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 169 */ 170 public static ExportImportConfiguration findByGroupId_First(long groupId, 171 OrderByComparator<ExportImportConfiguration> orderByComparator) 172 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 173 return getPersistence().findByGroupId_First(groupId, orderByComparator); 174 } 175 176 /** 177 * Returns the first export import configuration in the ordered set where groupId = ?. 178 * 179 * @param groupId the group ID 180 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 181 * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 182 */ 183 public static ExportImportConfiguration fetchByGroupId_First(long groupId, 184 OrderByComparator<ExportImportConfiguration> orderByComparator) { 185 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 186 } 187 188 /** 189 * Returns the last export import configuration in the ordered set where groupId = ?. 190 * 191 * @param groupId the group ID 192 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 193 * @return the last matching export import configuration 194 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 195 */ 196 public static ExportImportConfiguration findByGroupId_Last(long groupId, 197 OrderByComparator<ExportImportConfiguration> orderByComparator) 198 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 199 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 200 } 201 202 /** 203 * Returns the last export import configuration in the ordered set where groupId = ?. 204 * 205 * @param groupId the group ID 206 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 207 * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 208 */ 209 public static ExportImportConfiguration fetchByGroupId_Last(long groupId, 210 OrderByComparator<ExportImportConfiguration> orderByComparator) { 211 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 212 } 213 214 /** 215 * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = ?. 216 * 217 * @param exportImportConfigurationId the primary key of the current export import configuration 218 * @param groupId the group ID 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the previous, current, and next export import configuration 221 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 222 */ 223 public static ExportImportConfiguration[] findByGroupId_PrevAndNext( 224 long exportImportConfigurationId, long groupId, 225 OrderByComparator<ExportImportConfiguration> orderByComparator) 226 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 227 return getPersistence() 228 .findByGroupId_PrevAndNext(exportImportConfigurationId, 229 groupId, orderByComparator); 230 } 231 232 /** 233 * Removes all the export import configurations where groupId = ? from the database. 234 * 235 * @param groupId the group ID 236 */ 237 public static void removeByGroupId(long groupId) { 238 getPersistence().removeByGroupId(groupId); 239 } 240 241 /** 242 * Returns the number of export import configurations where groupId = ?. 243 * 244 * @param groupId the group ID 245 * @return the number of matching export import configurations 246 */ 247 public static int countByGroupId(long groupId) { 248 return getPersistence().countByGroupId(groupId); 249 } 250 251 /** 252 * Returns all the export import configurations where companyId = ?. 253 * 254 * @param companyId the company ID 255 * @return the matching export import configurations 256 */ 257 public static List<ExportImportConfiguration> findByCompanyId( 258 long companyId) { 259 return getPersistence().findByCompanyId(companyId); 260 } 261 262 /** 263 * Returns a range of all the export import configurations where companyId = ?. 264 * 265 * <p> 266 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 267 * </p> 268 * 269 * @param companyId the company ID 270 * @param start the lower bound of the range of export import configurations 271 * @param end the upper bound of the range of export import configurations (not inclusive) 272 * @return the range of matching export import configurations 273 */ 274 public static List<ExportImportConfiguration> findByCompanyId( 275 long companyId, int start, int end) { 276 return getPersistence().findByCompanyId(companyId, start, end); 277 } 278 279 /** 280 * Returns an ordered range of all the export import configurations where companyId = ?. 281 * 282 * <p> 283 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 284 * </p> 285 * 286 * @param companyId the company ID 287 * @param start the lower bound of the range of export import configurations 288 * @param end the upper bound of the range of export import configurations (not inclusive) 289 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 290 * @return the ordered range of matching export import configurations 291 */ 292 public static List<ExportImportConfiguration> findByCompanyId( 293 long companyId, int start, int end, 294 OrderByComparator<ExportImportConfiguration> orderByComparator) { 295 return getPersistence() 296 .findByCompanyId(companyId, start, end, orderByComparator); 297 } 298 299 /** 300 * Returns the first export import configuration in the ordered set where companyId = ?. 301 * 302 * @param companyId the company ID 303 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 304 * @return the first matching export import configuration 305 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 306 */ 307 public static ExportImportConfiguration findByCompanyId_First( 308 long companyId, 309 OrderByComparator<ExportImportConfiguration> orderByComparator) 310 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 311 return getPersistence() 312 .findByCompanyId_First(companyId, orderByComparator); 313 } 314 315 /** 316 * Returns the first export import configuration in the ordered set where companyId = ?. 317 * 318 * @param companyId the company ID 319 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 320 * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 321 */ 322 public static ExportImportConfiguration fetchByCompanyId_First( 323 long companyId, 324 OrderByComparator<ExportImportConfiguration> orderByComparator) { 325 return getPersistence() 326 .fetchByCompanyId_First(companyId, orderByComparator); 327 } 328 329 /** 330 * Returns the last export import configuration in the ordered set where companyId = ?. 331 * 332 * @param companyId the company ID 333 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 334 * @return the last matching export import configuration 335 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 336 */ 337 public static ExportImportConfiguration findByCompanyId_Last( 338 long companyId, 339 OrderByComparator<ExportImportConfiguration> orderByComparator) 340 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 341 return getPersistence() 342 .findByCompanyId_Last(companyId, orderByComparator); 343 } 344 345 /** 346 * Returns the last export import configuration in the ordered set where companyId = ?. 347 * 348 * @param companyId the company ID 349 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 350 * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 351 */ 352 public static ExportImportConfiguration fetchByCompanyId_Last( 353 long companyId, 354 OrderByComparator<ExportImportConfiguration> orderByComparator) { 355 return getPersistence() 356 .fetchByCompanyId_Last(companyId, orderByComparator); 357 } 358 359 /** 360 * Returns the export import configurations before and after the current export import configuration in the ordered set where companyId = ?. 361 * 362 * @param exportImportConfigurationId the primary key of the current export import configuration 363 * @param companyId the company ID 364 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 365 * @return the previous, current, and next export import configuration 366 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 367 */ 368 public static ExportImportConfiguration[] findByCompanyId_PrevAndNext( 369 long exportImportConfigurationId, long companyId, 370 OrderByComparator<ExportImportConfiguration> orderByComparator) 371 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 372 return getPersistence() 373 .findByCompanyId_PrevAndNext(exportImportConfigurationId, 374 companyId, orderByComparator); 375 } 376 377 /** 378 * Removes all the export import configurations where companyId = ? from the database. 379 * 380 * @param companyId the company ID 381 */ 382 public static void removeByCompanyId(long companyId) { 383 getPersistence().removeByCompanyId(companyId); 384 } 385 386 /** 387 * Returns the number of export import configurations where companyId = ?. 388 * 389 * @param companyId the company ID 390 * @return the number of matching export import configurations 391 */ 392 public static int countByCompanyId(long companyId) { 393 return getPersistence().countByCompanyId(companyId); 394 } 395 396 /** 397 * Returns all the export import configurations where groupId = ? and type = ?. 398 * 399 * @param groupId the group ID 400 * @param type the type 401 * @return the matching export import configurations 402 */ 403 public static List<ExportImportConfiguration> findByG_T(long groupId, 404 int type) { 405 return getPersistence().findByG_T(groupId, type); 406 } 407 408 /** 409 * Returns a range of all the export import configurations where groupId = ? and type = ?. 410 * 411 * <p> 412 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 413 * </p> 414 * 415 * @param groupId the group ID 416 * @param type the type 417 * @param start the lower bound of the range of export import configurations 418 * @param end the upper bound of the range of export import configurations (not inclusive) 419 * @return the range of matching export import configurations 420 */ 421 public static List<ExportImportConfiguration> findByG_T(long groupId, 422 int type, int start, int end) { 423 return getPersistence().findByG_T(groupId, type, start, end); 424 } 425 426 /** 427 * Returns an ordered range of all the export import configurations where groupId = ? and type = ?. 428 * 429 * <p> 430 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 431 * </p> 432 * 433 * @param groupId the group ID 434 * @param type the type 435 * @param start the lower bound of the range of export import configurations 436 * @param end the upper bound of the range of export import configurations (not inclusive) 437 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 438 * @return the ordered range of matching export import configurations 439 */ 440 public static List<ExportImportConfiguration> findByG_T(long groupId, 441 int type, int start, int end, 442 OrderByComparator<ExportImportConfiguration> orderByComparator) { 443 return getPersistence() 444 .findByG_T(groupId, type, start, end, orderByComparator); 445 } 446 447 /** 448 * Returns the first export import configuration in the ordered set where groupId = ? and type = ?. 449 * 450 * @param groupId the group ID 451 * @param type the type 452 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 453 * @return the first matching export import configuration 454 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 455 */ 456 public static ExportImportConfiguration findByG_T_First(long groupId, 457 int type, OrderByComparator<ExportImportConfiguration> orderByComparator) 458 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 459 return getPersistence().findByG_T_First(groupId, type, orderByComparator); 460 } 461 462 /** 463 * Returns the first export import configuration in the ordered set where groupId = ? and type = ?. 464 * 465 * @param groupId the group ID 466 * @param type the type 467 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 468 * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 469 */ 470 public static ExportImportConfiguration fetchByG_T_First(long groupId, 471 int type, OrderByComparator<ExportImportConfiguration> orderByComparator) { 472 return getPersistence() 473 .fetchByG_T_First(groupId, type, orderByComparator); 474 } 475 476 /** 477 * Returns the last export import configuration in the ordered set where groupId = ? and type = ?. 478 * 479 * @param groupId the group ID 480 * @param type the type 481 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 482 * @return the last matching export import configuration 483 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 484 */ 485 public static ExportImportConfiguration findByG_T_Last(long groupId, 486 int type, OrderByComparator<ExportImportConfiguration> orderByComparator) 487 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 488 return getPersistence().findByG_T_Last(groupId, type, orderByComparator); 489 } 490 491 /** 492 * Returns the last export import configuration in the ordered set where groupId = ? and type = ?. 493 * 494 * @param groupId the group ID 495 * @param type the type 496 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 497 * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 498 */ 499 public static ExportImportConfiguration fetchByG_T_Last(long groupId, 500 int type, OrderByComparator<ExportImportConfiguration> orderByComparator) { 501 return getPersistence().fetchByG_T_Last(groupId, type, orderByComparator); 502 } 503 504 /** 505 * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = ? and type = ?. 506 * 507 * @param exportImportConfigurationId the primary key of the current export import configuration 508 * @param groupId the group ID 509 * @param type the type 510 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 511 * @return the previous, current, and next export import configuration 512 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 513 */ 514 public static ExportImportConfiguration[] findByG_T_PrevAndNext( 515 long exportImportConfigurationId, long groupId, int type, 516 OrderByComparator<ExportImportConfiguration> orderByComparator) 517 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 518 return getPersistence() 519 .findByG_T_PrevAndNext(exportImportConfigurationId, groupId, 520 type, orderByComparator); 521 } 522 523 /** 524 * Removes all the export import configurations where groupId = ? and type = ? from the database. 525 * 526 * @param groupId the group ID 527 * @param type the type 528 */ 529 public static void removeByG_T(long groupId, int type) { 530 getPersistence().removeByG_T(groupId, type); 531 } 532 533 /** 534 * Returns the number of export import configurations where groupId = ? and type = ?. 535 * 536 * @param groupId the group ID 537 * @param type the type 538 * @return the number of matching export import configurations 539 */ 540 public static int countByG_T(long groupId, int type) { 541 return getPersistence().countByG_T(groupId, type); 542 } 543 544 /** 545 * Returns all the export import configurations where groupId = ? and status = ?. 546 * 547 * @param groupId the group ID 548 * @param status the status 549 * @return the matching export import configurations 550 */ 551 public static List<ExportImportConfiguration> findByG_S(long groupId, 552 int status) { 553 return getPersistence().findByG_S(groupId, status); 554 } 555 556 /** 557 * Returns a range of all the export import configurations where groupId = ? and status = ?. 558 * 559 * <p> 560 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 561 * </p> 562 * 563 * @param groupId the group ID 564 * @param status the status 565 * @param start the lower bound of the range of export import configurations 566 * @param end the upper bound of the range of export import configurations (not inclusive) 567 * @return the range of matching export import configurations 568 */ 569 public static List<ExportImportConfiguration> findByG_S(long groupId, 570 int status, int start, int end) { 571 return getPersistence().findByG_S(groupId, status, start, end); 572 } 573 574 /** 575 * Returns an ordered range of all the export import configurations where groupId = ? and status = ?. 576 * 577 * <p> 578 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 579 * </p> 580 * 581 * @param groupId the group ID 582 * @param status the status 583 * @param start the lower bound of the range of export import configurations 584 * @param end the upper bound of the range of export import configurations (not inclusive) 585 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 586 * @return the ordered range of matching export import configurations 587 */ 588 public static List<ExportImportConfiguration> findByG_S(long groupId, 589 int status, int start, int end, 590 OrderByComparator<ExportImportConfiguration> orderByComparator) { 591 return getPersistence() 592 .findByG_S(groupId, status, start, end, orderByComparator); 593 } 594 595 /** 596 * Returns the first export import configuration in the ordered set where groupId = ? and status = ?. 597 * 598 * @param groupId the group ID 599 * @param status the status 600 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 601 * @return the first matching export import configuration 602 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 603 */ 604 public static ExportImportConfiguration findByG_S_First(long groupId, 605 int status, 606 OrderByComparator<ExportImportConfiguration> orderByComparator) 607 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 608 return getPersistence() 609 .findByG_S_First(groupId, status, orderByComparator); 610 } 611 612 /** 613 * Returns the first export import configuration in the ordered set where groupId = ? and status = ?. 614 * 615 * @param groupId the group ID 616 * @param status the status 617 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 618 * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 619 */ 620 public static ExportImportConfiguration fetchByG_S_First(long groupId, 621 int status, 622 OrderByComparator<ExportImportConfiguration> orderByComparator) { 623 return getPersistence() 624 .fetchByG_S_First(groupId, status, orderByComparator); 625 } 626 627 /** 628 * Returns the last export import configuration in the ordered set where groupId = ? and status = ?. 629 * 630 * @param groupId the group ID 631 * @param status the status 632 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 633 * @return the last matching export import configuration 634 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 635 */ 636 public static ExportImportConfiguration findByG_S_Last(long groupId, 637 int status, 638 OrderByComparator<ExportImportConfiguration> orderByComparator) 639 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 640 return getPersistence() 641 .findByG_S_Last(groupId, status, orderByComparator); 642 } 643 644 /** 645 * Returns the last export import configuration in the ordered set where groupId = ? and status = ?. 646 * 647 * @param groupId the group ID 648 * @param status the status 649 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 650 * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 651 */ 652 public static ExportImportConfiguration fetchByG_S_Last(long groupId, 653 int status, 654 OrderByComparator<ExportImportConfiguration> orderByComparator) { 655 return getPersistence() 656 .fetchByG_S_Last(groupId, status, orderByComparator); 657 } 658 659 /** 660 * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = ? and status = ?. 661 * 662 * @param exportImportConfigurationId the primary key of the current export import configuration 663 * @param groupId the group ID 664 * @param status the status 665 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 666 * @return the previous, current, and next export import configuration 667 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 668 */ 669 public static ExportImportConfiguration[] findByG_S_PrevAndNext( 670 long exportImportConfigurationId, long groupId, int status, 671 OrderByComparator<ExportImportConfiguration> orderByComparator) 672 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 673 return getPersistence() 674 .findByG_S_PrevAndNext(exportImportConfigurationId, groupId, 675 status, orderByComparator); 676 } 677 678 /** 679 * Removes all the export import configurations where groupId = ? and status = ? from the database. 680 * 681 * @param groupId the group ID 682 * @param status the status 683 */ 684 public static void removeByG_S(long groupId, int status) { 685 getPersistence().removeByG_S(groupId, status); 686 } 687 688 /** 689 * Returns the number of export import configurations where groupId = ? and status = ?. 690 * 691 * @param groupId the group ID 692 * @param status the status 693 * @return the number of matching export import configurations 694 */ 695 public static int countByG_S(long groupId, int status) { 696 return getPersistence().countByG_S(groupId, status); 697 } 698 699 /** 700 * Returns all the export import configurations where groupId = ? and type = ? and status = ?. 701 * 702 * @param groupId the group ID 703 * @param type the type 704 * @param status the status 705 * @return the matching export import configurations 706 */ 707 public static List<ExportImportConfiguration> findByG_T_S(long groupId, 708 int type, int status) { 709 return getPersistence().findByG_T_S(groupId, type, status); 710 } 711 712 /** 713 * Returns a range of all the export import configurations where groupId = ? and type = ? and status = ?. 714 * 715 * <p> 716 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 717 * </p> 718 * 719 * @param groupId the group ID 720 * @param type the type 721 * @param status the status 722 * @param start the lower bound of the range of export import configurations 723 * @param end the upper bound of the range of export import configurations (not inclusive) 724 * @return the range of matching export import configurations 725 */ 726 public static List<ExportImportConfiguration> findByG_T_S(long groupId, 727 int type, int status, int start, int end) { 728 return getPersistence().findByG_T_S(groupId, type, status, start, end); 729 } 730 731 /** 732 * Returns an ordered range of all the export import configurations where groupId = ? and type = ? and status = ?. 733 * 734 * <p> 735 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 736 * </p> 737 * 738 * @param groupId the group ID 739 * @param type the type 740 * @param status the status 741 * @param start the lower bound of the range of export import configurations 742 * @param end the upper bound of the range of export import configurations (not inclusive) 743 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 744 * @return the ordered range of matching export import configurations 745 */ 746 public static List<ExportImportConfiguration> findByG_T_S(long groupId, 747 int type, int status, int start, int end, 748 OrderByComparator<ExportImportConfiguration> orderByComparator) { 749 return getPersistence() 750 .findByG_T_S(groupId, type, status, start, end, 751 orderByComparator); 752 } 753 754 /** 755 * Returns the first export import configuration in the ordered set where groupId = ? and type = ? and status = ?. 756 * 757 * @param groupId the group ID 758 * @param type the type 759 * @param status the status 760 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 761 * @return the first matching export import configuration 762 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 763 */ 764 public static ExportImportConfiguration findByG_T_S_First(long groupId, 765 int type, int status, 766 OrderByComparator<ExportImportConfiguration> orderByComparator) 767 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 768 return getPersistence() 769 .findByG_T_S_First(groupId, type, status, orderByComparator); 770 } 771 772 /** 773 * Returns the first export import configuration in the ordered set where groupId = ? and type = ? and status = ?. 774 * 775 * @param groupId the group ID 776 * @param type the type 777 * @param status the status 778 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 779 * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 780 */ 781 public static ExportImportConfiguration fetchByG_T_S_First(long groupId, 782 int type, int status, 783 OrderByComparator<ExportImportConfiguration> orderByComparator) { 784 return getPersistence() 785 .fetchByG_T_S_First(groupId, type, status, orderByComparator); 786 } 787 788 /** 789 * Returns the last export import configuration in the ordered set where groupId = ? and type = ? and status = ?. 790 * 791 * @param groupId the group ID 792 * @param type the type 793 * @param status the status 794 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 795 * @return the last matching export import configuration 796 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 797 */ 798 public static ExportImportConfiguration findByG_T_S_Last(long groupId, 799 int type, int status, 800 OrderByComparator<ExportImportConfiguration> orderByComparator) 801 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 802 return getPersistence() 803 .findByG_T_S_Last(groupId, type, status, orderByComparator); 804 } 805 806 /** 807 * Returns the last export import configuration in the ordered set where groupId = ? and type = ? and status = ?. 808 * 809 * @param groupId the group ID 810 * @param type the type 811 * @param status the status 812 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 813 * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 814 */ 815 public static ExportImportConfiguration fetchByG_T_S_Last(long groupId, 816 int type, int status, 817 OrderByComparator<ExportImportConfiguration> orderByComparator) { 818 return getPersistence() 819 .fetchByG_T_S_Last(groupId, type, status, orderByComparator); 820 } 821 822 /** 823 * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = ? and type = ? and status = ?. 824 * 825 * @param exportImportConfigurationId the primary key of the current export import configuration 826 * @param groupId the group ID 827 * @param type the type 828 * @param status the status 829 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 830 * @return the previous, current, and next export import configuration 831 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 832 */ 833 public static ExportImportConfiguration[] findByG_T_S_PrevAndNext( 834 long exportImportConfigurationId, long groupId, int type, int status, 835 OrderByComparator<ExportImportConfiguration> orderByComparator) 836 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 837 return getPersistence() 838 .findByG_T_S_PrevAndNext(exportImportConfigurationId, 839 groupId, type, status, orderByComparator); 840 } 841 842 /** 843 * Removes all the export import configurations where groupId = ? and type = ? and status = ? from the database. 844 * 845 * @param groupId the group ID 846 * @param type the type 847 * @param status the status 848 */ 849 public static void removeByG_T_S(long groupId, int type, int status) { 850 getPersistence().removeByG_T_S(groupId, type, status); 851 } 852 853 /** 854 * Returns the number of export import configurations where groupId = ? and type = ? and status = ?. 855 * 856 * @param groupId the group ID 857 * @param type the type 858 * @param status the status 859 * @return the number of matching export import configurations 860 */ 861 public static int countByG_T_S(long groupId, int type, int status) { 862 return getPersistence().countByG_T_S(groupId, type, status); 863 } 864 865 /** 866 * Caches the export import configuration in the entity cache if it is enabled. 867 * 868 * @param exportImportConfiguration the export import configuration 869 */ 870 public static void cacheResult( 871 ExportImportConfiguration exportImportConfiguration) { 872 getPersistence().cacheResult(exportImportConfiguration); 873 } 874 875 /** 876 * Caches the export import configurations in the entity cache if it is enabled. 877 * 878 * @param exportImportConfigurations the export import configurations 879 */ 880 public static void cacheResult( 881 List<ExportImportConfiguration> exportImportConfigurations) { 882 getPersistence().cacheResult(exportImportConfigurations); 883 } 884 885 /** 886 * Creates a new export import configuration with the primary key. Does not add the export import configuration to the database. 887 * 888 * @param exportImportConfigurationId the primary key for the new export import configuration 889 * @return the new export import configuration 890 */ 891 public static ExportImportConfiguration create( 892 long exportImportConfigurationId) { 893 return getPersistence().create(exportImportConfigurationId); 894 } 895 896 /** 897 * Removes the export import configuration with the primary key from the database. Also notifies the appropriate model listeners. 898 * 899 * @param exportImportConfigurationId the primary key of the export import configuration 900 * @return the export import configuration that was removed 901 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 902 */ 903 public static ExportImportConfiguration remove( 904 long exportImportConfigurationId) 905 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 906 return getPersistence().remove(exportImportConfigurationId); 907 } 908 909 public static ExportImportConfiguration updateImpl( 910 ExportImportConfiguration exportImportConfiguration) { 911 return getPersistence().updateImpl(exportImportConfiguration); 912 } 913 914 /** 915 * Returns the export import configuration with the primary key or throws a {@link NoSuchConfigurationException} if it could not be found. 916 * 917 * @param exportImportConfigurationId the primary key of the export import configuration 918 * @return the export import configuration 919 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 920 */ 921 public static ExportImportConfiguration findByPrimaryKey( 922 long exportImportConfigurationId) 923 throws com.liferay.portlet.exportimport.NoSuchConfigurationException { 924 return getPersistence().findByPrimaryKey(exportImportConfigurationId); 925 } 926 927 /** 928 * Returns the export import configuration with the primary key or returns <code>null</code> if it could not be found. 929 * 930 * @param exportImportConfigurationId the primary key of the export import configuration 931 * @return the export import configuration, or <code>null</code> if a export import configuration with the primary key could not be found 932 */ 933 public static ExportImportConfiguration fetchByPrimaryKey( 934 long exportImportConfigurationId) { 935 return getPersistence().fetchByPrimaryKey(exportImportConfigurationId); 936 } 937 938 public static java.util.Map<java.io.Serializable, ExportImportConfiguration> fetchByPrimaryKeys( 939 java.util.Set<java.io.Serializable> primaryKeys) { 940 return getPersistence().fetchByPrimaryKeys(primaryKeys); 941 } 942 943 /** 944 * Returns all the export import configurations. 945 * 946 * @return the export import configurations 947 */ 948 public static List<ExportImportConfiguration> findAll() { 949 return getPersistence().findAll(); 950 } 951 952 /** 953 * Returns a range of all the export import configurations. 954 * 955 * <p> 956 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 957 * </p> 958 * 959 * @param start the lower bound of the range of export import configurations 960 * @param end the upper bound of the range of export import configurations (not inclusive) 961 * @return the range of export import configurations 962 */ 963 public static List<ExportImportConfiguration> findAll(int start, int end) { 964 return getPersistence().findAll(start, end); 965 } 966 967 /** 968 * Returns an ordered range of all the export import configurations. 969 * 970 * <p> 971 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. 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. 972 * </p> 973 * 974 * @param start the lower bound of the range of export import configurations 975 * @param end the upper bound of the range of export import configurations (not inclusive) 976 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 977 * @return the ordered range of export import configurations 978 */ 979 public static List<ExportImportConfiguration> findAll(int start, int end, 980 OrderByComparator<ExportImportConfiguration> orderByComparator) { 981 return getPersistence().findAll(start, end, orderByComparator); 982 } 983 984 /** 985 * Removes all the export import configurations from the database. 986 */ 987 public static void removeAll() { 988 getPersistence().removeAll(); 989 } 990 991 /** 992 * Returns the number of export import configurations. 993 * 994 * @return the number of export import configurations 995 */ 996 public static int countAll() { 997 return getPersistence().countAll(); 998 } 999 1000 public static ExportImportConfigurationPersistence getPersistence() { 1001 if (_persistence == null) { 1002 _persistence = (ExportImportConfigurationPersistence)PortalBeanLocatorUtil.locate(ExportImportConfigurationPersistence.class.getName()); 1003 1004 ReferenceRegistry.registerReference(ExportImportConfigurationUtil.class, 1005 "_persistence"); 1006 } 1007 1008 return _persistence; 1009 } 1010 1011 /** 1012 * @deprecated As of 6.2.0 1013 */ 1014 @Deprecated 1015 public void setPersistence(ExportImportConfigurationPersistence persistence) { 1016 } 1017 1018 private static ExportImportConfigurationPersistence _persistence; 1019 }