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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63; and type = &#63;.
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 = &#63; and type = &#63;.
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 = &#63; and type = &#63;.
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 = &#63; and type = &#63;.
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 = &#63; and type = &#63;.
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 = &#63; and type = &#63;.
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 = &#63; and type = &#63;.
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 = &#63; and type = &#63;.
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 = &#63; and type = &#63; 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 = &#63; and type = &#63;.
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 = &#63; and status = &#63;.
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 = &#63; and status = &#63;.
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 = &#63; and status = &#63;.
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 = &#63; and status = &#63;.
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 = &#63; and status = &#63;.
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 = &#63; and status = &#63;.
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 = &#63; and status = &#63;.
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 = &#63; and status = &#63;.
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 = &#63; and status = &#63; 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 = &#63; and status = &#63;.
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 = &#63; and type = &#63; and status = &#63;.
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 = &#63; and type = &#63; and status = &#63;.
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 = &#63; and type = &#63; and status = &#63;.
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 = &#63; and type = &#63; and status = &#63;.
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 = &#63; and type = &#63; and status = &#63;.
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 = &#63; and type = &#63; and status = &#63;.
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 = &#63; and type = &#63; and status = &#63;.
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 = &#63; and type = &#63; and status = &#63;.
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 = &#63; and type = &#63; and status = &#63; 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 = &#63; and type = &#63; and status = &#63;.
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    }