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.dynamicdatamapping.service;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.util.ReferenceRegistry;
021    
022    /**
023     * Provides the local service utility for DDMStructure. This utility wraps
024     * {@link com.liferay.portlet.dynamicdatamapping.service.impl.DDMStructureLocalServiceImpl} and is the
025     * primary access point for service operations in application layer code running
026     * on the local server. Methods of this service will not have security checks
027     * based on the propagated JAAS credentials because this service can only be
028     * accessed from within the same VM.
029     *
030     * @author Brian Wing Shun Chan
031     * @see DDMStructureLocalService
032     * @see com.liferay.portlet.dynamicdatamapping.service.base.DDMStructureLocalServiceBaseImpl
033     * @see com.liferay.portlet.dynamicdatamapping.service.impl.DDMStructureLocalServiceImpl
034     * @generated
035     */
036    @ProviderType
037    public class DDMStructureLocalServiceUtil {
038            /*
039             * NOTE FOR DEVELOPERS:
040             *
041             * Never modify this class directly. Add custom service methods to {@link com.liferay.portlet.dynamicdatamapping.service.impl.DDMStructureLocalServiceImpl} and rerun ServiceBuilder to regenerate this class.
042             */
043    
044            /**
045            * Adds the d d m structure to the database. Also notifies the appropriate model listeners.
046            *
047            * @param ddmStructure the d d m structure
048            * @return the d d m structure that was added
049            */
050            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure addDDMStructure(
051                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
052                    return getService().addDDMStructure(ddmStructure);
053            }
054    
055            public static void addDLFileEntryTypeDDMStructure(long fileEntryTypeId,
056                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
057                    getService()
058                            .addDLFileEntryTypeDDMStructure(fileEntryTypeId, ddmStructure);
059            }
060    
061            public static void addDLFileEntryTypeDDMStructure(long fileEntryTypeId,
062                    long structureId) {
063                    getService().addDLFileEntryTypeDDMStructure(fileEntryTypeId, structureId);
064            }
065    
066            public static void addDLFileEntryTypeDDMStructures(long fileEntryTypeId,
067                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) {
068                    getService()
069                            .addDLFileEntryTypeDDMStructures(fileEntryTypeId, DDMStructures);
070            }
071    
072            public static void addDLFileEntryTypeDDMStructures(long fileEntryTypeId,
073                    long[] structureIds) {
074                    getService()
075                            .addDLFileEntryTypeDDMStructures(fileEntryTypeId, structureIds);
076            }
077    
078            public static void addJournalFolderDDMStructure(long folderId,
079                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
080                    getService().addJournalFolderDDMStructure(folderId, ddmStructure);
081            }
082    
083            public static void addJournalFolderDDMStructure(long folderId,
084                    long structureId) {
085                    getService().addJournalFolderDDMStructure(folderId, structureId);
086            }
087    
088            public static void addJournalFolderDDMStructures(long folderId,
089                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) {
090                    getService().addJournalFolderDDMStructures(folderId, DDMStructures);
091            }
092    
093            public static void addJournalFolderDDMStructures(long folderId,
094                    long[] structureIds) {
095                    getService().addJournalFolderDDMStructures(folderId, structureIds);
096            }
097    
098            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
099                    long userId, long groupId, long classNameId,
100                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
101                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
102                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
103                    com.liferay.portal.service.ServiceContext serviceContext)
104                    throws com.liferay.portal.kernel.exception.PortalException {
105                    return getService()
106                                       .addStructure(userId, groupId, classNameId, nameMap,
107                            descriptionMap, ddmForm, serviceContext);
108            }
109    
110            /**
111            * Adds a structure referencing a default parent structure, using the portal
112            * property <code>dynamic.data.lists.storage.type</code> storage type and
113            * default structure type.
114            *
115            * @param userId the primary key of the structure's creator/owner
116            * @param groupId the primary key of the group
117            * @param classNameId the primary key of the class name for the
118            structure's related model
119            * @param nameMap the structure's locales and localized names
120            * @param descriptionMap the structure's locales and localized
121            descriptions
122            * @param definition the structure's XML schema definition
123            * @param serviceContext the service context to be applied. Can set the
124            UUID, creation date, modification date, guest permissions,
125            and group permissions for the structure.
126            * @return the structure
127            * @throws PortalException if a user with the primary key could not be
128            found, if the XSD was not well-formed, or if a portal
129            exception occurred
130            * @deprecated As of 7.0.0, replaced by {@link #addStructure(long, long,
131            long, Map, Map, DDMForm, ServiceContext)}
132            */
133            @Deprecated
134            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
135                    long userId, long groupId, long classNameId,
136                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
137                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
138                    java.lang.String definition,
139                    com.liferay.portal.service.ServiceContext serviceContext)
140                    throws com.liferay.portal.kernel.exception.PortalException {
141                    return getService()
142                                       .addStructure(userId, groupId, classNameId, nameMap,
143                            descriptionMap, definition, serviceContext);
144            }
145    
146            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
147                    long userId, long groupId, long parentStructureId, long classNameId,
148                    java.lang.String structureKey,
149                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
150                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
151                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
152                    java.lang.String storageType, int type,
153                    com.liferay.portal.service.ServiceContext serviceContext)
154                    throws com.liferay.portal.kernel.exception.PortalException {
155                    return getService()
156                                       .addStructure(userId, groupId, parentStructureId,
157                            classNameId, structureKey, nameMap, descriptionMap, ddmForm,
158                            storageType, type, serviceContext);
159            }
160    
161            /**
162            * Adds a structure referencing its parent structure.
163            *
164            * @param userId the primary key of the structure's creator/owner
165            * @param groupId the primary key of the group
166            * @param parentStructureId the primary key of the parent structure
167            (optionally {@link
168            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants#DEFAULT_PARENT_STRUCTURE_ID})
169            * @param classNameId the primary key of the class name for the
170            structure's related model
171            * @param structureKey the unique string identifying the structure
172            (optionally <code>null</code>)
173            * @param nameMap the structure's locales and localized names
174            * @param descriptionMap the structure's locales and localized
175            descriptions
176            * @param definition the structure's XML schema definition
177            * @param storageType the structure's storage type. It can be "xml" or
178            "expando". For more information, see {@link
179            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
180            * @param type the structure's type. For more information, see {@link
181            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
182            * @param serviceContext the service context to be applied. Can set the
183            UUID, creation date, modification date, guest permissions,
184            and group permissions for the structure.
185            * @return the structure
186            * @throws PortalException if a user with the primary key could not be
187            found, if the XSD was not well-formed, or if a portal
188            exception occurred
189            * @deprecated As of 7.0.0, replaced by {@link #addStructure(long, long,
190            long, long, String, Map, Map, DDMForm, String, int,
191            ServiceContext)}
192            */
193            @Deprecated
194            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
195                    long userId, long groupId, long parentStructureId, long classNameId,
196                    java.lang.String structureKey,
197                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
198                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
199                    java.lang.String definition, java.lang.String storageType, int type,
200                    com.liferay.portal.service.ServiceContext serviceContext)
201                    throws com.liferay.portal.kernel.exception.PortalException {
202                    return getService()
203                                       .addStructure(userId, groupId, parentStructureId,
204                            classNameId, structureKey, nameMap, descriptionMap, definition,
205                            storageType, type, serviceContext);
206            }
207    
208            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
209                    long userId, long groupId, java.lang.String parentStructureKey,
210                    long classNameId, java.lang.String structureKey,
211                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
212                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
213                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
214                    java.lang.String storageType, int type,
215                    com.liferay.portal.service.ServiceContext serviceContext)
216                    throws com.liferay.portal.kernel.exception.PortalException {
217                    return getService()
218                                       .addStructure(userId, groupId, parentStructureKey,
219                            classNameId, structureKey, nameMap, descriptionMap, ddmForm,
220                            storageType, type, serviceContext);
221            }
222    
223            /**
224            * Adds a structure referencing a default parent structure if the parent
225            * structure is not found.
226            *
227            * @param userId the primary key of the structure's creator/owner
228            * @param groupId the primary key of the group
229            * @param parentStructureKey the unique string identifying the parent
230            structure (optionally <code>null</code>)
231            * @param classNameId the primary key of the class name for the
232            structure's related model
233            * @param structureKey the unique string identifying the structure
234            (optionally <code>null</code>)
235            * @param nameMap the structure's locales and localized names
236            * @param descriptionMap the structure's locales and localized
237            descriptions
238            * @param definition the structure's XML schema definition
239            * @param storageType the structure's storage type. It can be "xml" or
240            "expando". For more information, see {@link
241            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
242            * @param type the structure's type. For more information, see {@link
243            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
244            * @param serviceContext the service context to be applied. Can set the
245            UUID, creation date, modification date, guest permissions and
246            group permissions for the structure.
247            * @return the structure
248            * @throws PortalException if a user with the primary key could not be
249            found, if the XSD was not well-formed, or if a portal
250            exception occurred
251            * @deprecated As of 7.0.0, replaced by {@link #addStructure(long, long,
252            String, long, String, Map, Map, DDMForm, String, int,
253            ServiceContext)}
254            */
255            @Deprecated
256            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
257                    long userId, long groupId, java.lang.String parentStructureKey,
258                    long classNameId, java.lang.String structureKey,
259                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
260                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
261                    java.lang.String definition, java.lang.String storageType, int type,
262                    com.liferay.portal.service.ServiceContext serviceContext)
263                    throws com.liferay.portal.kernel.exception.PortalException {
264                    return getService()
265                                       .addStructure(userId, groupId, parentStructureKey,
266                            classNameId, structureKey, nameMap, descriptionMap, definition,
267                            storageType, type, serviceContext);
268            }
269    
270            /**
271            * Adds the resources to the structure.
272            *
273            * @param structure the structure to add resources to
274            * @param addGroupPermissions whether to add group permissions
275            * @param addGuestPermissions whether to add guest permissions
276            * @throws PortalException if a portal exception occurred
277            */
278            public static void addStructureResources(
279                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure,
280                    boolean addGroupPermissions, boolean addGuestPermissions)
281                    throws com.liferay.portal.kernel.exception.PortalException {
282                    getService()
283                            .addStructureResources(structure, addGroupPermissions,
284                            addGuestPermissions);
285            }
286    
287            /**
288            * Adds the model resources with the permissions to the structure.
289            *
290            * @param structure the structure to add resources to
291            * @param groupPermissions the group permissions to be added
292            * @param guestPermissions the guest permissions to be added
293            * @throws PortalException if a portal exception occurred
294            */
295            public static void addStructureResources(
296                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure,
297                    java.lang.String[] groupPermissions, java.lang.String[] guestPermissions)
298                    throws com.liferay.portal.kernel.exception.PortalException {
299                    getService()
300                            .addStructureResources(structure, groupPermissions, guestPermissions);
301            }
302    
303            public static void clearDLFileEntryTypeDDMStructures(long fileEntryTypeId) {
304                    getService().clearDLFileEntryTypeDDMStructures(fileEntryTypeId);
305            }
306    
307            public static void clearJournalFolderDDMStructures(long folderId) {
308                    getService().clearJournalFolderDDMStructures(folderId);
309            }
310    
311            /**
312            * Copies a structure, creating a new structure with all the values
313            * extracted from the original one. The new structure supports a new name
314            * and description.
315            *
316            * @param userId the primary key of the structure's creator/owner
317            * @param structureId the primary key of the structure to be copied
318            * @param nameMap the new structure's locales and localized names
319            * @param descriptionMap the new structure's locales and localized
320            descriptions
321            * @param serviceContext the service context to be applied. Can set the
322            UUID, creation date, modification date, guest permissions, and
323            group permissions for the structure.
324            * @return the new structure
325            * @throws PortalException if a portal exception occurred
326            */
327            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure copyStructure(
328                    long userId, long structureId,
329                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
330                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
331                    com.liferay.portal.service.ServiceContext serviceContext)
332                    throws com.liferay.portal.kernel.exception.PortalException {
333                    return getService()
334                                       .copyStructure(userId, structureId, nameMap, descriptionMap,
335                            serviceContext);
336            }
337    
338            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure copyStructure(
339                    long userId, long structureId,
340                    com.liferay.portal.service.ServiceContext serviceContext)
341                    throws com.liferay.portal.kernel.exception.PortalException {
342                    return getService().copyStructure(userId, structureId, serviceContext);
343            }
344    
345            /**
346            * Creates a new d d m structure with the primary key. Does not add the d d m structure to the database.
347            *
348            * @param structureId the primary key for the new d d m structure
349            * @return the new d d m structure
350            */
351            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure createDDMStructure(
352                    long structureId) {
353                    return getService().createDDMStructure(structureId);
354            }
355    
356            /**
357            * Deletes the d d m structure from the database. Also notifies the appropriate model listeners.
358            *
359            * @param ddmStructure the d d m structure
360            * @return the d d m structure that was removed
361            */
362            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure deleteDDMStructure(
363                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
364                    return getService().deleteDDMStructure(ddmStructure);
365            }
366    
367            /**
368            * Deletes the d d m structure with the primary key from the database. Also notifies the appropriate model listeners.
369            *
370            * @param structureId the primary key of the d d m structure
371            * @return the d d m structure that was removed
372            * @throws PortalException if a d d m structure with the primary key could not be found
373            */
374            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure deleteDDMStructure(
375                    long structureId)
376                    throws com.liferay.portal.kernel.exception.PortalException {
377                    return getService().deleteDDMStructure(structureId);
378            }
379    
380            public static void deleteDLFileEntryTypeDDMStructure(long fileEntryTypeId,
381                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
382                    getService()
383                            .deleteDLFileEntryTypeDDMStructure(fileEntryTypeId, ddmStructure);
384            }
385    
386            public static void deleteDLFileEntryTypeDDMStructure(long fileEntryTypeId,
387                    long structureId) {
388                    getService()
389                            .deleteDLFileEntryTypeDDMStructure(fileEntryTypeId, structureId);
390            }
391    
392            public static void deleteDLFileEntryTypeDDMStructures(
393                    long fileEntryTypeId,
394                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) {
395                    getService()
396                            .deleteDLFileEntryTypeDDMStructures(fileEntryTypeId, DDMStructures);
397            }
398    
399            public static void deleteDLFileEntryTypeDDMStructures(
400                    long fileEntryTypeId, long[] structureIds) {
401                    getService()
402                            .deleteDLFileEntryTypeDDMStructures(fileEntryTypeId, structureIds);
403            }
404    
405            public static void deleteJournalFolderDDMStructure(long folderId,
406                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
407                    getService().deleteJournalFolderDDMStructure(folderId, ddmStructure);
408            }
409    
410            public static void deleteJournalFolderDDMStructure(long folderId,
411                    long structureId) {
412                    getService().deleteJournalFolderDDMStructure(folderId, structureId);
413            }
414    
415            public static void deleteJournalFolderDDMStructures(long folderId,
416                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) {
417                    getService().deleteJournalFolderDDMStructures(folderId, DDMStructures);
418            }
419    
420            public static void deleteJournalFolderDDMStructures(long folderId,
421                    long[] structureIds) {
422                    getService().deleteJournalFolderDDMStructures(folderId, structureIds);
423            }
424    
425            /**
426            * @throws PortalException
427            */
428            public static com.liferay.portal.model.PersistedModel deletePersistedModel(
429                    com.liferay.portal.model.PersistedModel persistedModel)
430                    throws com.liferay.portal.kernel.exception.PortalException {
431                    return getService().deletePersistedModel(persistedModel);
432            }
433    
434            /**
435            * Deletes the matching structure and its resources.
436            *
437            * <p>
438            * Before deleting the structure, the system verifies whether the structure
439            * is required by another entity. If it is needed, an exception is thrown.
440            * </p>
441            *
442            * @param groupId the primary key of the group
443            * @param classNameId the primary key of the class name for the structure's
444            related model
445            * @param structureKey the unique string identifying the structure
446            * @throws PortalException if a portal exception occurred
447            */
448            public static void deleteStructure(long groupId, long classNameId,
449                    java.lang.String structureKey)
450                    throws com.liferay.portal.kernel.exception.PortalException {
451                    getService().deleteStructure(groupId, classNameId, structureKey);
452            }
453    
454            /**
455            * Deletes the structure and its resources.
456            *
457            * <p>
458            * Before deleting the structure, this method verifies whether the structure
459            * is required by another entity. If it is needed, an exception is thrown.
460            * </p>
461            *
462            * @param structure the structure to be deleted
463            * @throws PortalException if a portal exception occurred
464            */
465            public static void deleteStructure(
466                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure)
467                    throws com.liferay.portal.kernel.exception.PortalException {
468                    getService().deleteStructure(structure);
469            }
470    
471            /**
472            * Deletes the structure and its resources.
473            *
474            * <p>
475            * Before deleting the structure, the system verifies whether the structure
476            * is required by another entity. If it is needed, an exception is thrown.
477            * </p>
478            *
479            * @param structureId the primary key of the structure to be deleted
480            * @throws PortalException if a portal exception occurred
481            */
482            public static void deleteStructure(long structureId)
483                    throws com.liferay.portal.kernel.exception.PortalException {
484                    getService().deleteStructure(structureId);
485            }
486    
487            /**
488            * Deletes all the structures of the group.
489            *
490            * <p>
491            * Before deleting the structures, the system verifies whether each
492            * structure is required by another entity. If any of the structures are
493            * needed, an exception is thrown.
494            * </p>
495            *
496            * @param groupId the primary key of the group
497            * @throws PortalException if a portal exception occurred
498            */
499            public static void deleteStructures(long groupId)
500                    throws com.liferay.portal.kernel.exception.PortalException {
501                    getService().deleteStructures(groupId);
502            }
503    
504            public static void deleteStructures(long groupId, long classNameId)
505                    throws com.liferay.portal.kernel.exception.PortalException {
506                    getService().deleteStructures(groupId, classNameId);
507            }
508    
509            public static com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
510                    return getService().dynamicQuery();
511            }
512    
513            /**
514            * Performs a dynamic query on the database and returns the matching rows.
515            *
516            * @param dynamicQuery the dynamic query
517            * @return the matching rows
518            */
519            public static <T> java.util.List<T> dynamicQuery(
520                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
521                    return getService().dynamicQuery(dynamicQuery);
522            }
523    
524            /**
525            * Performs a dynamic query on the database and returns a range of the matching rows.
526            *
527            * <p>
528            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
529            * </p>
530            *
531            * @param dynamicQuery the dynamic query
532            * @param start the lower bound of the range of model instances
533            * @param end the upper bound of the range of model instances (not inclusive)
534            * @return the range of matching rows
535            */
536            public static <T> java.util.List<T> dynamicQuery(
537                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
538                    int end) {
539                    return getService().dynamicQuery(dynamicQuery, start, end);
540            }
541    
542            /**
543            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
544            *
545            * <p>
546            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
547            * </p>
548            *
549            * @param dynamicQuery the dynamic query
550            * @param start the lower bound of the range of model instances
551            * @param end the upper bound of the range of model instances (not inclusive)
552            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
553            * @return the ordered range of matching rows
554            */
555            public static <T> java.util.List<T> dynamicQuery(
556                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
557                    int end,
558                    com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) {
559                    return getService()
560                                       .dynamicQuery(dynamicQuery, start, end, orderByComparator);
561            }
562    
563            /**
564            * Returns the number of rows matching the dynamic query.
565            *
566            * @param dynamicQuery the dynamic query
567            * @return the number of rows matching the dynamic query
568            */
569            public static long dynamicQueryCount(
570                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
571                    return getService().dynamicQueryCount(dynamicQuery);
572            }
573    
574            /**
575            * Returns the number of rows matching the dynamic query.
576            *
577            * @param dynamicQuery the dynamic query
578            * @param projection the projection to apply to the query
579            * @return the number of rows matching the dynamic query
580            */
581            public static long dynamicQueryCount(
582                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
583                    com.liferay.portal.kernel.dao.orm.Projection projection) {
584                    return getService().dynamicQueryCount(dynamicQuery, projection);
585            }
586    
587            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchDDMStructure(
588                    long structureId) {
589                    return getService().fetchDDMStructure(structureId);
590            }
591    
592            /**
593            * Returns the d d m structure matching the UUID and group.
594            *
595            * @param uuid the d d m structure's UUID
596            * @param groupId the primary key of the group
597            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
598            */
599            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchDDMStructureByUuidAndGroupId(
600                    java.lang.String uuid, long groupId) {
601                    return getService().fetchDDMStructureByUuidAndGroupId(uuid, groupId);
602            }
603    
604            /**
605            * Returns the structure matching the class name ID, structure key, and
606            * group.
607            *
608            * @param groupId the primary key of the group
609            * @param classNameId the primary key of the class name for the structure's
610            related model
611            * @param structureKey the unique string identifying the structure
612            * @return the matching structure, or <code>null</code> if a matching
613            structure could not be found
614            */
615            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
616                    long groupId, long classNameId, java.lang.String structureKey) {
617                    return getService().fetchStructure(groupId, classNameId, structureKey);
618            }
619    
620            /**
621            * Returns the structure matching the class name ID, structure key, and
622            * group, optionally searching ancestor sites (that have sharing enabled)
623            * and global scoped sites.
624            *
625            * <p>
626            * This method first searches in the group. If the structure is still not
627            * found and <code>includeAncestorStructures</code> is set to
628            * <code>true</code>, this method searches the group's ancestor sites (that
629            * have sharing enabled) and lastly searches global scoped sites.
630            * </p>
631            *
632            * @param groupId the primary key of the group
633            * @param classNameId the primary key of the class name for the structure's
634            related model
635            * @param structureKey the unique string identifying the structure
636            * @param includeAncestorStructures whether to include ancestor sites (that
637            have sharing enabled) and include global scoped sites in the
638            search
639            * @return the matching structure, or <code>null</code> if a matching
640            structure could not be found
641            * @throws PortalException if a portal exception occurred
642            */
643            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
644                    long groupId, long classNameId, java.lang.String structureKey,
645                    boolean includeAncestorStructures)
646                    throws com.liferay.portal.kernel.exception.PortalException {
647                    return getService()
648                                       .fetchStructure(groupId, classNameId, structureKey,
649                            includeAncestorStructures);
650            }
651    
652            /**
653            * Returns the structure with the ID.
654            *
655            * @param structureId the primary key of the structure
656            * @return the structure with the structure ID, or <code>null</code> if a
657            matching structure could not be found
658            */
659            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
660                    long structureId) {
661                    return getService().fetchStructure(structureId);
662            }
663    
664            public static com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() {
665                    return getService().getActionableDynamicQuery();
666            }
667    
668            /**
669            * Returns the Spring bean ID for this bean.
670            *
671            * @return the Spring bean ID for this bean
672            */
673            public static java.lang.String getBeanIdentifier() {
674                    return getService().getBeanIdentifier();
675            }
676    
677            /**
678            * @deprecated As of 6.2.0, replaced by {@link #getClassStructures(long,
679            long)}
680            */
681            @Deprecated
682            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
683                    long classNameId) {
684                    return getService().getClassStructures(classNameId);
685            }
686    
687            /**
688            * @deprecated As of 6.2.0, replaced by {@link #getClassStructures(long,
689            long, OrderByComparator)}
690            */
691            @Deprecated
692            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
693                    long classNameId,
694                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
695                    return getService().getClassStructures(classNameId, orderByComparator);
696            }
697    
698            /**
699            * @deprecated As of 6.2.0, replaced by {@link #getClassStructures(long,
700            long, int, int)}
701            */
702            @Deprecated
703            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
704                    long classNameId, int start, int end) {
705                    return getService().getClassStructures(classNameId, start, end);
706            }
707    
708            /**
709            * Returns all the structures matching the class name ID.
710            *
711            * @param companyId the primary key of the structure's company
712            * @param classNameId the primary key of the class name for the structure's
713            related model
714            * @return the structures matching the class name ID
715            */
716            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
717                    long companyId, long classNameId) {
718                    return getService().getClassStructures(companyId, classNameId);
719            }
720    
721            /**
722            * Returns all the structures matching the class name ID ordered by the
723            * comparator.
724            *
725            * @param companyId the primary key of the structure's company
726            * @param classNameId the primary key of the class name for the structure's
727            related model
728            * @param orderByComparator the comparator to order the structures
729            (optionally <code>null</code>)
730            * @return the matching structures ordered by the comparator
731            */
732            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
733                    long companyId, long classNameId,
734                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
735                    return getService()
736                                       .getClassStructures(companyId, classNameId, orderByComparator);
737            }
738    
739            /**
740            * Returns a range of all the structures matching the class name ID.
741            *
742            * <p>
743            * Useful when paginating results. Returns a maximum of <code>end -
744            * start</code> instances. <code>start</code> and <code>end</code> are not
745            * primary keys, they are indexes in the result set. Thus, <code>0</code>
746            * refers to the first result in the set. Setting both <code>start</code>
747            * and <code>end</code> to {@link
748            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
749            * result set.
750            * </p>
751            *
752            * @param companyId the primary key of the structure's company
753            * @param classNameId the primary key of the class name for the structure's
754            related model
755            * @param start the lower bound of the range of structures to return
756            * @param end the upper bound of the range of structures to return (not
757            inclusive)
758            * @return the range of matching structures
759            */
760            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
761                    long companyId, long classNameId, int start, int end) {
762                    return getService()
763                                       .getClassStructures(companyId, classNameId, start, end);
764            }
765    
766            /**
767            * Returns the d d m structure with the primary key.
768            *
769            * @param structureId the primary key of the d d m structure
770            * @return the d d m structure
771            * @throws PortalException if a d d m structure with the primary key could not be found
772            */
773            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure getDDMStructure(
774                    long structureId)
775                    throws com.liferay.portal.kernel.exception.PortalException {
776                    return getService().getDDMStructure(structureId);
777            }
778    
779            /**
780            * Returns the d d m structure matching the UUID and group.
781            *
782            * @param uuid the d d m structure's UUID
783            * @param groupId the primary key of the group
784            * @return the matching d d m structure
785            * @throws PortalException if a matching d d m structure could not be found
786            */
787            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure getDDMStructureByUuidAndGroupId(
788                    java.lang.String uuid, long groupId)
789                    throws com.liferay.portal.kernel.exception.PortalException {
790                    return getService().getDDMStructureByUuidAndGroupId(uuid, groupId);
791            }
792    
793            /**
794            * Returns a range of all the d d m structures.
795            *
796            * <p>
797            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
798            * </p>
799            *
800            * @param start the lower bound of the range of d d m structures
801            * @param end the upper bound of the range of d d m structures (not inclusive)
802            * @return the range of d d m structures
803            */
804            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructures(
805                    int start, int end) {
806                    return getService().getDDMStructures(start, end);
807            }
808    
809            /**
810            * Returns all the d d m structures matching the UUID and company.
811            *
812            * @param uuid the UUID of the d d m structures
813            * @param companyId the primary key of the company
814            * @return the matching d d m structures, or an empty list if no matches were found
815            */
816            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructuresByUuidAndCompanyId(
817                    java.lang.String uuid, long companyId) {
818                    return getService().getDDMStructuresByUuidAndCompanyId(uuid, companyId);
819            }
820    
821            /**
822            * Returns a range of d d m structures matching the UUID and company.
823            *
824            * @param uuid the UUID of the d d m structures
825            * @param companyId the primary key of the company
826            * @param start the lower bound of the range of d d m structures
827            * @param end the upper bound of the range of d d m structures (not inclusive)
828            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
829            * @return the range of matching d d m structures, or an empty list if no matches were found
830            */
831            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructuresByUuidAndCompanyId(
832                    java.lang.String uuid, long companyId, int start, int end,
833                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
834                    return getService()
835                                       .getDDMStructuresByUuidAndCompanyId(uuid, companyId, start,
836                            end, orderByComparator);
837            }
838    
839            /**
840            * Returns the number of d d m structures.
841            *
842            * @return the number of d d m structures
843            */
844            public static int getDDMStructuresCount() {
845                    return getService().getDDMStructuresCount();
846            }
847    
848            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeDDMStructures(
849                    long fileEntryTypeId) {
850                    return getService().getDLFileEntryTypeDDMStructures(fileEntryTypeId);
851            }
852    
853            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeDDMStructures(
854                    long fileEntryTypeId, int start, int end) {
855                    return getService()
856                                       .getDLFileEntryTypeDDMStructures(fileEntryTypeId, start, end);
857            }
858    
859            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeDDMStructures(
860                    long fileEntryTypeId, int start, int end,
861                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
862                    return getService()
863                                       .getDLFileEntryTypeDDMStructures(fileEntryTypeId, start,
864                            end, orderByComparator);
865            }
866    
867            public static int getDLFileEntryTypeDDMStructuresCount(long fileEntryTypeId) {
868                    return getService().getDLFileEntryTypeDDMStructuresCount(fileEntryTypeId);
869            }
870    
871            /**
872            * Returns the fileEntryTypeIds of the document library file entry types associated with the d d m structure.
873            *
874            * @param structureId the structureId of the d d m structure
875            * @return long[] the fileEntryTypeIds of document library file entry types associated with the d d m structure
876            */
877            public static long[] getDLFileEntryTypePrimaryKeys(long structureId) {
878                    return getService().getDLFileEntryTypePrimaryKeys(structureId);
879            }
880    
881            /**
882            * Returns all the structures for the document library file entry type.
883            *
884            * @param dlFileEntryTypeId the primary key of the document library file
885            entry type
886            * @return the structures for the document library file entry type
887            */
888            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeStructures(
889                    long dlFileEntryTypeId) {
890                    return getService().getDLFileEntryTypeStructures(dlFileEntryTypeId);
891            }
892    
893            public static com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery(
894                    com.liferay.portal.kernel.lar.PortletDataContext portletDataContext) {
895                    return getService().getExportActionableDynamicQuery(portletDataContext);
896            }
897    
898            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderDDMStructures(
899                    long folderId) {
900                    return getService().getJournalFolderDDMStructures(folderId);
901            }
902    
903            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderDDMStructures(
904                    long folderId, int start, int end) {
905                    return getService().getJournalFolderDDMStructures(folderId, start, end);
906            }
907    
908            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderDDMStructures(
909                    long folderId, int start, int end,
910                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
911                    return getService()
912                                       .getJournalFolderDDMStructures(folderId, start, end,
913                            orderByComparator);
914            }
915    
916            public static int getJournalFolderDDMStructuresCount(long folderId) {
917                    return getService().getJournalFolderDDMStructuresCount(folderId);
918            }
919    
920            /**
921            * Returns the folderIds of the journal folders associated with the d d m structure.
922            *
923            * @param structureId the structureId of the d d m structure
924            * @return long[] the folderIds of journal folders associated with the d d m structure
925            */
926            public static long[] getJournalFolderPrimaryKeys(long structureId) {
927                    return getService().getJournalFolderPrimaryKeys(structureId);
928            }
929    
930            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderStructures(
931                    long[] groupIds, long journalFolderId, int restrictionType)
932                    throws com.liferay.portal.kernel.exception.PortalException {
933                    return getService()
934                                       .getJournalFolderStructures(groupIds, journalFolderId,
935                            restrictionType);
936            }
937    
938            public static com.liferay.portal.model.PersistedModel getPersistedModel(
939                    java.io.Serializable primaryKeyObj)
940                    throws com.liferay.portal.kernel.exception.PortalException {
941                    return getService().getPersistedModel(primaryKeyObj);
942            }
943    
944            /**
945            * Returns the structure matching the class name ID, structure key, and
946            * group.
947            *
948            * @param groupId the primary key of the structure's group
949            * @param classNameId the primary key of the class name for the structure's
950            related model
951            * @param structureKey the unique string identifying the structure
952            * @return the matching structure
953            * @throws PortalException if a matching structure could not be found
954            */
955            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
956                    long groupId, long classNameId, java.lang.String structureKey)
957                    throws com.liferay.portal.kernel.exception.PortalException {
958                    return getService().getStructure(groupId, classNameId, structureKey);
959            }
960    
961            /**
962            * Returns the structure matching the class name ID, structure key, and
963            * group, optionally searching ancestor sites (that have sharing enabled)
964            * and global scoped sites.
965            *
966            * <p>
967            * This method first searches in the group. If the structure is still not
968            * found and <code>includeAncestorStructures</code> is set to
969            * <code>true</code>, this method searches the group's ancestor sites (that
970            * have sharing enabled) and lastly searches global scoped sites.
971            * </p>
972            *
973            * @param groupId the primary key of the structure's group
974            * @param classNameId the primary key of the class name for the structure's
975            related model
976            * @param structureKey the unique string identifying the structure
977            * @param includeAncestorStructures whether to include ancestor sites (that
978            have sharing enabled) and include global scoped sites in the
979            search in the search
980            * @return the matching structure
981            * @throws PortalException if a matching structure could not be found
982            */
983            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
984                    long groupId, long classNameId, java.lang.String structureKey,
985                    boolean includeAncestorStructures)
986                    throws com.liferay.portal.kernel.exception.PortalException {
987                    return getService()
988                                       .getStructure(groupId, classNameId, structureKey,
989                            includeAncestorStructures);
990            }
991    
992            /**
993            * Returns all the structures matching the group, name, and description.
994            *
995            * @param groupId the primary key of the structure's group
996            * @param name the structure's name
997            * @param description the structure's description
998            * @return the matching structures
999            */
1000            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructure(
1001                    long groupId, java.lang.String name, java.lang.String description) {
1002                    return getService().getStructure(groupId, name, description);
1003            }
1004    
1005            /**
1006            * Returns the structure with the ID.
1007            *
1008            * @param structureId the primary key of the structure
1009            * @return the structure with the ID
1010            * @throws PortalException if a structure with the ID could not be found
1011            */
1012            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
1013                    long structureId)
1014                    throws com.liferay.portal.kernel.exception.PortalException {
1015                    return getService().getStructure(structureId);
1016            }
1017    
1018            /**
1019            * @deprecated As of 6.2.0, replaced by {@link #getStructures}
1020            */
1021            @Deprecated
1022            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries() {
1023                    return getService().getStructureEntries();
1024            }
1025    
1026            /**
1027            * @deprecated As of 6.2.0, replaced by {@link #getStructures(long)}
1028            */
1029            @Deprecated
1030            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries(
1031                    long groupId) {
1032                    return getService().getStructureEntries(groupId);
1033            }
1034    
1035            /**
1036            * @deprecated As of 6.2.0, replaced by {@link #getStructures(long, int,
1037            int)}
1038            */
1039            @Deprecated
1040            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries(
1041                    long groupId, int start, int end) {
1042                    return getService().getStructureEntries(groupId, start, end);
1043            }
1044    
1045            /**
1046            * Returns all the structures present in the system.
1047            *
1048            * @return the structures present in the system
1049            */
1050            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures() {
1051                    return getService().getStructures();
1052            }
1053    
1054            /**
1055            * Returns all the structures present in the group.
1056            *
1057            * @param groupId the primary key of the group
1058            * @return the structures present in the group
1059            */
1060            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1061                    long groupId) {
1062                    return getService().getStructures(groupId);
1063            }
1064    
1065            /**
1066            * Returns all the structures matching class name ID and group.
1067            *
1068            * @param groupId the primary key of the group
1069            * @param classNameId the primary key of the class name for the structure's
1070            related model
1071            * @return the matching structures
1072            */
1073            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1074                    long groupId, long classNameId) {
1075                    return getService().getStructures(groupId, classNameId);
1076            }
1077    
1078            /**
1079            * Returns a range of all the structures that match the class name ID and
1080            * group.
1081            *
1082            * <p>
1083            * Useful when paginating results. Returns a maximum of <code>end -
1084            * start</code> instances. <code>start</code> and <code>end</code> are not
1085            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1086            * refers to the first result in the set. Setting both <code>start</code>
1087            * and <code>end</code> to {@link
1088            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1089            * result set.
1090            * </p>
1091            *
1092            * @param groupId the primary key of the group
1093            * @param classNameId the primary key of the class name for the structure's
1094            related model
1095            * @param start the lower bound of the range of structures to return
1096            * @param end the upper bound of the range of structures to return (not
1097            inclusive)
1098            * @return the range of matching structures
1099            */
1100            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1101                    long groupId, long classNameId, int start, int end) {
1102                    return getService().getStructures(groupId, classNameId, start, end);
1103            }
1104    
1105            /**
1106            * Returns an ordered range of all the structures matching the class name ID
1107            * and group.
1108            *
1109            * <p>
1110            * Useful when paginating results. Returns a maximum of <code>end -
1111            * start</code> instances. <code>start</code> and <code>end</code> are not
1112            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1113            * refers to the first result in the set. Setting both <code>start</code>
1114            * and <code>end</code> to {@link
1115            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1116            * result set.
1117            * </p>
1118            *
1119            * @param groupId the primary key of the group
1120            * @param classNameId the primary key of the class name for the structure's
1121            related model
1122            * @param start the lower bound of the range of structures to return
1123            * @param end the upper bound of the range of structures to return (not
1124            inclusive)
1125            * @param orderByComparator the comparator to order the structures
1126            (optionally <code>null</code>)
1127            * @return the range of matching structures ordered by the comparator
1128            */
1129            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1130                    long groupId, long classNameId, int start, int end,
1131                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
1132                    return getService()
1133                                       .getStructures(groupId, classNameId, start, end,
1134                            orderByComparator);
1135            }
1136    
1137            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1138                    long groupId, java.lang.String name, java.lang.String description) {
1139                    return getService().getStructures(groupId, name, description);
1140            }
1141    
1142            /**
1143            * Returns a range of all the structures belonging to the group.
1144            *
1145            * <p>
1146            * Useful when paginating results. Returns a maximum of <code>end -
1147            * start</code> instances. <code>start</code> and <code>end</code> are not
1148            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1149            * refers to the first result in the set. Setting both <code>start</code>
1150            * and <code>end</code> to {@link
1151            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1152            * result set.
1153            * </p>
1154            *
1155            * @param groupId the primary key of the group
1156            * @param start the lower bound of the range of structures to return
1157            * @param end the upper bound of the range of structures to return (not
1158            inclusive)
1159            * @return the range of matching structures
1160            */
1161            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1162                    long groupId, int start, int end) {
1163                    return getService().getStructures(groupId, start, end);
1164            }
1165    
1166            /**
1167            * Returns all the structures belonging to the groups.
1168            *
1169            * @param groupIds the primary keys of the groups
1170            * @return the structures belonging to the groups
1171            */
1172            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1173                    long[] groupIds) {
1174                    return getService().getStructures(groupIds);
1175            }
1176    
1177            /**
1178            * Returns all the structures matching the class name ID and belonging to
1179            * the groups.
1180            *
1181            * @param groupIds the primary keys of the groups
1182            * @param classNameId the primary key of the class name for the structure's
1183            related model
1184            * @return the matching structures
1185            */
1186            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1187                    long[] groupIds, long classNameId) {
1188                    return getService().getStructures(groupIds, classNameId);
1189            }
1190    
1191            /**
1192            * Returns a range of all the structures matching the class name ID and
1193            * belonging to the groups.
1194            *
1195            * <p>
1196            * Useful when paginating results. Returns a maximum of <code>end -
1197            * start</code> instances. <code>start</code> and <code>end</code> are not
1198            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1199            * refers to the first result in the set. Setting both <code>start</code>
1200            * and <code>end</code> to {@link
1201            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1202            * result set.
1203            * </p>
1204            *
1205            * @param groupIds the primary keys of the groups
1206            * @param classNameId the primary key of the class name for the structure's
1207            related model
1208            * @param start the lower bound of the range of structures to return
1209            * @param end the upper bound of the range of structures to return (not
1210            inclusive)
1211            * @return the range of matching structures
1212            */
1213            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1214                    long[] groupIds, long classNameId, int start, int end) {
1215                    return getService().getStructures(groupIds, classNameId, start, end);
1216            }
1217    
1218            /**
1219            * Returns the number of structures belonging to the group.
1220            *
1221            * @param groupId the primary key of the group
1222            * @return the number of structures belonging to the group
1223            */
1224            public static int getStructuresCount(long groupId) {
1225                    return getService().getStructuresCount(groupId);
1226            }
1227    
1228            /**
1229            * Returns the number of structures matching the class name ID and group.
1230            *
1231            * @param groupId the primary key of the group
1232            * @param classNameId the primary key of the class name for the structure's
1233            related model
1234            * @return the number of matching structures
1235            */
1236            public static int getStructuresCount(long groupId, long classNameId) {
1237                    return getService().getStructuresCount(groupId, classNameId);
1238            }
1239    
1240            /**
1241            * Returns the number of structures matching the class name ID and belonging
1242            * to the groups.
1243            *
1244            * @param groupIds the primary keys of the groups
1245            * @param classNameId the primary key of the class name for the structure's
1246            related model
1247            * @return the number of matching structures
1248            */
1249            public static int getStructuresCount(long[] groupIds, long classNameId) {
1250                    return getService().getStructuresCount(groupIds, classNameId);
1251            }
1252    
1253            public static boolean hasDLFileEntryTypeDDMStructure(long fileEntryTypeId,
1254                    long structureId) {
1255                    return getService()
1256                                       .hasDLFileEntryTypeDDMStructure(fileEntryTypeId, structureId);
1257            }
1258    
1259            public static boolean hasDLFileEntryTypeDDMStructures(long fileEntryTypeId) {
1260                    return getService().hasDLFileEntryTypeDDMStructures(fileEntryTypeId);
1261            }
1262    
1263            public static boolean hasJournalFolderDDMStructure(long folderId,
1264                    long structureId) {
1265                    return getService().hasJournalFolderDDMStructure(folderId, structureId);
1266            }
1267    
1268            public static boolean hasJournalFolderDDMStructures(long folderId) {
1269                    return getService().hasJournalFolderDDMStructures(folderId);
1270            }
1271    
1272            /**
1273            * Returns an ordered range of all the structures matching the groups and
1274            * class name IDs, and matching the keywords in the structure names and
1275            * descriptions.
1276            *
1277            * <p>
1278            * Useful when paginating results. Returns a maximum of <code>end -
1279            * start</code> instances. <code>start</code> and <code>end</code> are not
1280            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1281            * refers to the first result in the set. Setting both <code>start</code>
1282            * and <code>end</code> to {@link
1283            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1284            * result set.
1285            * </p>
1286            *
1287            * @param companyId the primary key of the structure's company
1288            * @param groupIds the primary keys of the groups
1289            * @param classNameIds the primary keys of the class names of the models
1290            the structures are related to
1291            * @param keywords the keywords (space separated), which may occur in the
1292            structure's name or description (optionally <code>null</code>)
1293            * @param start the lower bound of the range of structures to return
1294            * @param end the upper bound of the range of structures to return (not
1295            inclusive)
1296            * @param orderByComparator the comparator to order the structures
1297            (optionally <code>null</code>)
1298            * @return the range of matching structures ordered by the comparator
1299            */
1300            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> search(
1301                    long companyId, long[] groupIds, long[] classNameIds,
1302                    java.lang.String keywords, int start, int end,
1303                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
1304                    return getService()
1305                                       .search(companyId, groupIds, classNameIds, keywords, start,
1306                            end, orderByComparator);
1307            }
1308    
1309            /**
1310            * Returns an ordered range of all the structures matching the groups, class
1311            * name IDs, name keyword, description keyword, storage type, and type.
1312            *
1313            * <p>
1314            * Useful when paginating results. Returns a maximum of <code>end -
1315            * start</code> instances. <code>start</code> and <code>end</code> are not
1316            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1317            * refers to the first result in the set. Setting both <code>start</code>
1318            * and <code>end</code> to {@link
1319            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1320            * result set.
1321            * </p>
1322            *
1323            * @param companyId the primary key of the structure's company
1324            * @param groupIds the primary keys of the groups
1325            * @param classNameIds the primary keys of the class names of the models
1326            the structures are related to
1327            * @param name the name keywords
1328            * @param description the description keywords
1329            * @param storageType the structure's storage type. It can be "xml" or
1330            "expando". For more information, see {@link
1331            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
1332            * @param type the structure's type. For more information, see {@link
1333            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
1334            * @param andOperator whether every field must match its keywords, or just
1335            one field
1336            * @param start the lower bound of the range of structures to return
1337            * @param end the upper bound of the range of structures to return (not
1338            inclusive)
1339            * @param orderByComparator the comparator to order the structures
1340            (optionally <code>null</code>)
1341            * @return the range of matching structures ordered by the comparator
1342            */
1343            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> search(
1344                    long companyId, long[] groupIds, long[] classNameIds,
1345                    java.lang.String name, java.lang.String description,
1346                    java.lang.String storageType, int type, boolean andOperator, int start,
1347                    int end,
1348                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
1349                    return getService()
1350                                       .search(companyId, groupIds, classNameIds, name,
1351                            description, storageType, type, andOperator, start, end,
1352                            orderByComparator);
1353            }
1354    
1355            /**
1356            * Returns the number of structures matching the groups and class name IDs,
1357            * and matching the keywords in the structure names and descriptions.
1358            *
1359            * @param companyId the primary key of the structure's company
1360            * @param groupIds the primary keys of the groups
1361            * @param classNameIds the primary keys of the class names of the models
1362            the structures are related to
1363            * @param keywords the keywords (space separated), which may occur in the
1364            structure's name or description (optionally <code>null</code>)
1365            * @return the number of matching structures
1366            */
1367            public static int searchCount(long companyId, long[] groupIds,
1368                    long[] classNameIds, java.lang.String keywords) {
1369                    return getService()
1370                                       .searchCount(companyId, groupIds, classNameIds, keywords);
1371            }
1372    
1373            /**
1374            * Returns the number of structures matching the groups, class name IDs,
1375            * name keyword, description keyword, storage type, and type
1376            *
1377            * @param companyId the primary key of the structure's company
1378            * @param groupIds the primary keys of the groups
1379            * @param classNameIds the primary keys of the class names of the models
1380            the structure's are related to
1381            * @param name the name keywords
1382            * @param description the description keywords
1383            * @param storageType the structure's storage type. It can be "xml" or
1384            "expando". For more information, see {@link
1385            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
1386            * @param type the structure's type. For more information, see {@link
1387            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
1388            * @param andOperator whether every field must match its keywords, or just
1389            one field
1390            * @return the number of matching structures
1391            */
1392            public static int searchCount(long companyId, long[] groupIds,
1393                    long[] classNameIds, java.lang.String name,
1394                    java.lang.String description, java.lang.String storageType, int type,
1395                    boolean andOperator) {
1396                    return getService()
1397                                       .searchCount(companyId, groupIds, classNameIds, name,
1398                            description, storageType, type, andOperator);
1399            }
1400    
1401            /**
1402            * Sets the Spring bean ID for this bean.
1403            *
1404            * @param beanIdentifier the Spring bean ID for this bean
1405            */
1406            public static void setBeanIdentifier(java.lang.String beanIdentifier) {
1407                    getService().setBeanIdentifier(beanIdentifier);
1408            }
1409    
1410            public static void setDLFileEntryTypeDDMStructures(long fileEntryTypeId,
1411                    long[] structureIds) {
1412                    getService()
1413                            .setDLFileEntryTypeDDMStructures(fileEntryTypeId, structureIds);
1414            }
1415    
1416            public static void setJournalFolderDDMStructures(long folderId,
1417                    long[] structureIds) {
1418                    getService().setJournalFolderDDMStructures(folderId, structureIds);
1419            }
1420    
1421            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateDDMForm(
1422                    long structureId,
1423                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
1424                    com.liferay.portal.service.ServiceContext serviceContext)
1425                    throws com.liferay.portal.kernel.exception.PortalException {
1426                    return getService().updateDDMForm(structureId, ddmForm, serviceContext);
1427            }
1428    
1429            /**
1430            * Updates the d d m structure in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
1431            *
1432            * @param ddmStructure the d d m structure
1433            * @return the d d m structure that was updated
1434            */
1435            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateDDMStructure(
1436                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
1437                    return getService().updateDDMStructure(ddmStructure);
1438            }
1439    
1440            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
1441                    long groupId, long parentStructureId, long classNameId,
1442                    java.lang.String structureKey,
1443                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1444                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1445                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
1446                    com.liferay.portal.service.ServiceContext serviceContext)
1447                    throws com.liferay.portal.kernel.exception.PortalException {
1448                    return getService()
1449                                       .updateStructure(groupId, parentStructureId, classNameId,
1450                            structureKey, nameMap, descriptionMap, ddmForm, serviceContext);
1451            }
1452    
1453            /**
1454            * Updates the structure matching the class name ID, structure key, and
1455            * group, replacing its old parent structure, name map, description map, and
1456            * XSD with new ones.
1457            *
1458            * @param groupId the primary key of the group
1459            * @param parentStructureId the primary key of the new parent structure
1460            * @param classNameId the primary key of the class name for the
1461            structure's related model
1462            * @param structureKey the unique string identifying the structure
1463            * @param nameMap the structure's new locales and localized names
1464            * @param descriptionMap the structure's new locales and localized
1465            description
1466            * @param definition the structure's new XML schema definition
1467            * @param serviceContext the service context to be applied. Can set the
1468            structure's modification date.
1469            * @return the updated structure
1470            * @throws PortalException if a matching structure could not be found,
1471            if the XSD was not well-formed, or if a portal exception
1472            occurred
1473            * @deprecated As of 7.0.0, replaced by {@link #updateStructure(long, long,
1474            long, String, Map, Map, DDMForm, ServiceContext)}
1475            */
1476            @Deprecated
1477            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
1478                    long groupId, long parentStructureId, long classNameId,
1479                    java.lang.String structureKey,
1480                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1481                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1482                    java.lang.String definition,
1483                    com.liferay.portal.service.ServiceContext serviceContext)
1484                    throws com.liferay.portal.kernel.exception.PortalException {
1485                    return getService()
1486                                       .updateStructure(groupId, parentStructureId, classNameId,
1487                            structureKey, nameMap, descriptionMap, definition, serviceContext);
1488            }
1489    
1490            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
1491                    long structureId, long parentStructureId,
1492                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1493                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1494                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
1495                    com.liferay.portal.service.ServiceContext serviceContext)
1496                    throws com.liferay.portal.kernel.exception.PortalException {
1497                    return getService()
1498                                       .updateStructure(structureId, parentStructureId, nameMap,
1499                            descriptionMap, ddmForm, serviceContext);
1500            }
1501    
1502            /**
1503            * Updates the structure matching the structure ID, replacing its old parent
1504            * structure, name map, description map, and XSD with new ones.
1505            *
1506            * @param structureId the primary key of the structure
1507            * @param parentStructureId the primary key of the new parent structure
1508            * @param nameMap the structure's new locales and localized names
1509            * @param descriptionMap the structure's new locales and localized
1510            descriptions
1511            * @param definition the structure's new XML schema definition
1512            * @param serviceContext the service context to be applied. Can set the
1513            structure's modification date.
1514            * @return the updated structure
1515            * @throws PortalException if a matching structure could not be found,
1516            if the XSD was not well-formed, or if a portal exception
1517            occurred
1518            * @deprecated As of 7.0.0, replaced by {@link #updateStructure(long, long,
1519            Map, Map, DDMForm, ServiceContext)}
1520            */
1521            @Deprecated
1522            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
1523                    long structureId, long parentStructureId,
1524                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1525                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1526                    java.lang.String definition,
1527                    com.liferay.portal.service.ServiceContext serviceContext)
1528                    throws com.liferay.portal.kernel.exception.PortalException {
1529                    return getService()
1530                                       .updateStructure(structureId, parentStructureId, nameMap,
1531                            descriptionMap, definition, serviceContext);
1532            }
1533    
1534            /**
1535            * Updates the structure matching the structure ID, replacing its XSD with a
1536            * new one.
1537            *
1538            * @param structureId the primary key of the structure
1539            * @param definition the structure's new XML schema definition
1540            * @param serviceContext the service context to be applied. Can set the
1541            structure's modification date.
1542            * @return the updated structure
1543            * @throws PortalException if a matching structure could not be found,
1544            if the XSD was not well-formed, or if a portal exception
1545            occurred
1546            * @deprecated As of 7.0.0, replaced by {@link #updateDDMForm(long, String,
1547            ServiceContext)}
1548            */
1549            @Deprecated
1550            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateXSD(
1551                    long structureId, java.lang.String definition,
1552                    com.liferay.portal.service.ServiceContext serviceContext)
1553                    throws com.liferay.portal.kernel.exception.PortalException {
1554                    return getService().updateXSD(structureId, definition, serviceContext);
1555            }
1556    
1557            public static DDMStructureLocalService getService() {
1558                    if (_service == null) {
1559                            _service = (DDMStructureLocalService)PortalBeanLocatorUtil.locate(DDMStructureLocalService.class.getName());
1560    
1561                            ReferenceRegistry.registerReference(DDMStructureLocalServiceUtil.class,
1562                                    "_service");
1563                    }
1564    
1565                    return _service;
1566            }
1567    
1568            /**
1569             * @deprecated As of 6.2.0
1570             */
1571            @Deprecated
1572            public void setService(DDMStructureLocalService service) {
1573            }
1574    
1575            private static DDMStructureLocalService _service;
1576    }