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.service.ServiceWrapper;
020    
021    /**
022     * Provides a wrapper for {@link DDMTemplateLocalService}.
023     *
024     * @author Brian Wing Shun Chan
025     * @see DDMTemplateLocalService
026     * @generated
027     */
028    @ProviderType
029    public class DDMTemplateLocalServiceWrapper implements DDMTemplateLocalService,
030            ServiceWrapper<DDMTemplateLocalService> {
031            public DDMTemplateLocalServiceWrapper(
032                    DDMTemplateLocalService ddmTemplateLocalService) {
033                    _ddmTemplateLocalService = ddmTemplateLocalService;
034            }
035    
036            /**
037            * Adds the d d m template to the database. Also notifies the appropriate model listeners.
038            *
039            * @param ddmTemplate the d d m template
040            * @return the d d m template that was added
041            */
042            @Override
043            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate addDDMTemplate(
044                    com.liferay.portlet.dynamicdatamapping.model.DDMTemplate ddmTemplate) {
045                    return _ddmTemplateLocalService.addDDMTemplate(ddmTemplate);
046            }
047    
048            /**
049            * Adds a template.
050            *
051            * @param userId the primary key of the template's creator/owner
052            * @param groupId the primary key of the group
053            * @param classNameId the primary key of the class name for the template's
054            related model
055            * @param classPK the primary key of the template's related entity
056            * @param nameMap the template's locales and localized names
057            * @param descriptionMap the template's locales and localized descriptions
058            * @param type the template's type. For more information, see {@link
059            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
060            * @param mode the template's mode. For more information, see {@link
061            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
062            * @param language the template's script language. For more information,
063            see {@link
064            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
065            * @param script the template's script
066            * @param serviceContext the service context to be applied. Can set the
067            UUID, creation date, modification date, guest permissions, and
068            group permissions for the template.
069            * @return the template
070            * @throws PortalException if a portal exception occurred
071            */
072            @Override
073            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate addTemplate(
074                    long userId, long groupId, long classNameId, long classPK,
075                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
076                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
077                    java.lang.String type, java.lang.String mode,
078                    java.lang.String language, java.lang.String script,
079                    com.liferay.portal.service.ServiceContext serviceContext)
080                    throws com.liferay.portal.kernel.exception.PortalException {
081                    return _ddmTemplateLocalService.addTemplate(userId, groupId,
082                            classNameId, classPK, nameMap, descriptionMap, type, mode,
083                            language, script, serviceContext);
084            }
085    
086            /**
087            * Adds a template with additional parameters.
088            *
089            * @param userId the primary key of the template's creator/owner
090            * @param groupId the primary key of the group
091            * @param classNameId the primary key of the class name for the template's
092            related model
093            * @param classPK the primary key of the template's related entity
094            * @param templateKey the unique string identifying the template
095            (optionally <code>null</code>)
096            * @param nameMap the template's locales and localized names
097            * @param descriptionMap the template's locales and localized descriptions
098            * @param type the template's type. For more information, see {@link
099            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
100            * @param mode the template's mode. For more information, see {@link
101            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
102            * @param language the template's script language. For more information,
103            see {@link
104            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
105            * @param script the template's script
106            * @param cacheable whether the template is cacheable
107            * @param smallImage whether the template has a small image
108            * @param smallImageURL the template's small image URL (optionally
109            <code>null</code>)
110            * @param smallImageFile the template's small image file (optionally
111            <code>null</code>)
112            * @param serviceContext the service context to be applied. Can set the
113            UUID, creation date, modification date, guest permissions, and
114            group permissions for the template.
115            * @return the template
116            * @throws PortalException if a portal exception occurred
117            */
118            @Override
119            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate addTemplate(
120                    long userId, long groupId, long classNameId, long classPK,
121                    java.lang.String templateKey,
122                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
123                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
124                    java.lang.String type, java.lang.String mode,
125                    java.lang.String language, java.lang.String script, boolean cacheable,
126                    boolean smallImage, java.lang.String smallImageURL,
127                    java.io.File smallImageFile,
128                    com.liferay.portal.service.ServiceContext serviceContext)
129                    throws com.liferay.portal.kernel.exception.PortalException {
130                    return _ddmTemplateLocalService.addTemplate(userId, groupId,
131                            classNameId, classPK, templateKey, nameMap, descriptionMap, type,
132                            mode, language, script, cacheable, smallImage, smallImageURL,
133                            smallImageFile, serviceContext);
134            }
135    
136            /**
137            * Adds the resources to the template.
138            *
139            * @param template the template to add resources to
140            * @param addGroupPermissions whether to add group permissions
141            * @param addGuestPermissions whether to add guest permissions
142            * @throws PortalException if a portal exception occurred
143            */
144            @Override
145            public void addTemplateResources(
146                    com.liferay.portlet.dynamicdatamapping.model.DDMTemplate template,
147                    boolean addGroupPermissions, boolean addGuestPermissions)
148                    throws com.liferay.portal.kernel.exception.PortalException {
149                    _ddmTemplateLocalService.addTemplateResources(template,
150                            addGroupPermissions, addGuestPermissions);
151            }
152    
153            /**
154            * Adds the model resources with the permissions to the template.
155            *
156            * @param template the template to add resources to
157            * @param groupPermissions the group permissions to be added
158            * @param guestPermissions the guest permissions to be added
159            * @throws PortalException if a portal exception occurred
160            */
161            @Override
162            public void addTemplateResources(
163                    com.liferay.portlet.dynamicdatamapping.model.DDMTemplate template,
164                    java.lang.String[] groupPermissions, java.lang.String[] guestPermissions)
165                    throws com.liferay.portal.kernel.exception.PortalException {
166                    _ddmTemplateLocalService.addTemplateResources(template,
167                            groupPermissions, guestPermissions);
168            }
169    
170            /**
171            * Copies the template, creating a new template with all the values
172            * extracted from the original one. This method supports defining a new name
173            * and description.
174            *
175            * @param userId the primary key of the template's creator/owner
176            * @param templateId the primary key of the template to be copied
177            * @param nameMap the new template's locales and localized names
178            * @param descriptionMap the new template's locales and localized
179            descriptions
180            * @param serviceContext the service context to be applied. Can set the
181            UUID, creation date, modification date, guest permissions, and
182            group permissions for the template.
183            * @return the new template
184            * @throws PortalException if a portal exception occurred
185            */
186            @Override
187            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate copyTemplate(
188                    long userId, long templateId,
189                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
190                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
191                    com.liferay.portal.service.ServiceContext serviceContext)
192                    throws com.liferay.portal.kernel.exception.PortalException {
193                    return _ddmTemplateLocalService.copyTemplate(userId, templateId,
194                            nameMap, descriptionMap, serviceContext);
195            }
196    
197            @Override
198            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate copyTemplate(
199                    long userId, long templateId,
200                    com.liferay.portal.service.ServiceContext serviceContext)
201                    throws com.liferay.portal.kernel.exception.PortalException {
202                    return _ddmTemplateLocalService.copyTemplate(userId, templateId,
203                            serviceContext);
204            }
205    
206            /**
207            * Copies all the templates matching the class name ID, class PK, and type.
208            * This method creates new templates, extracting all the values from the old
209            * ones and updating their class PKs.
210            *
211            * @param userId the primary key of the template's creator/owner
212            * @param classNameId the primary key of the class name for the template's
213            related model
214            * @param oldClassPK the primary key of the old template's related entity
215            * @param newClassPK the primary key of the new template's related entity
216            * @param type the template's type. For more information, see {@link
217            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
218            * @param serviceContext the service context to be applied. Can set the
219            creation date, modification date, guest permissions, and group
220            permissions for the new templates.
221            * @return the new templates
222            * @throws PortalException if a portal exception occurred
223            */
224            @Override
225            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> copyTemplates(
226                    long userId, long classNameId, long oldClassPK, long newClassPK,
227                    java.lang.String type,
228                    com.liferay.portal.service.ServiceContext serviceContext)
229                    throws com.liferay.portal.kernel.exception.PortalException {
230                    return _ddmTemplateLocalService.copyTemplates(userId, classNameId,
231                            oldClassPK, newClassPK, type, serviceContext);
232            }
233    
234            /**
235            * Creates a new d d m template with the primary key. Does not add the d d m template to the database.
236            *
237            * @param templateId the primary key for the new d d m template
238            * @return the new d d m template
239            */
240            @Override
241            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate createDDMTemplate(
242                    long templateId) {
243                    return _ddmTemplateLocalService.createDDMTemplate(templateId);
244            }
245    
246            /**
247            * Deletes the d d m template from the database. Also notifies the appropriate model listeners.
248            *
249            * @param ddmTemplate the d d m template
250            * @return the d d m template that was removed
251            */
252            @Override
253            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate deleteDDMTemplate(
254                    com.liferay.portlet.dynamicdatamapping.model.DDMTemplate ddmTemplate) {
255                    return _ddmTemplateLocalService.deleteDDMTemplate(ddmTemplate);
256            }
257    
258            /**
259            * Deletes the d d m template with the primary key from the database. Also notifies the appropriate model listeners.
260            *
261            * @param templateId the primary key of the d d m template
262            * @return the d d m template that was removed
263            * @throws PortalException if a d d m template with the primary key could not be found
264            */
265            @Override
266            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate deleteDDMTemplate(
267                    long templateId)
268                    throws com.liferay.portal.kernel.exception.PortalException {
269                    return _ddmTemplateLocalService.deleteDDMTemplate(templateId);
270            }
271    
272            /**
273            * @throws PortalException
274            */
275            @Override
276            public com.liferay.portal.model.PersistedModel deletePersistedModel(
277                    com.liferay.portal.model.PersistedModel persistedModel)
278                    throws com.liferay.portal.kernel.exception.PortalException {
279                    return _ddmTemplateLocalService.deletePersistedModel(persistedModel);
280            }
281    
282            /**
283            * Deletes the template and its resources.
284            *
285            * @param template the template to be deleted
286            * @throws PortalException if a portal exception occurred
287            */
288            @Override
289            public void deleteTemplate(
290                    com.liferay.portlet.dynamicdatamapping.model.DDMTemplate template)
291                    throws com.liferay.portal.kernel.exception.PortalException {
292                    _ddmTemplateLocalService.deleteTemplate(template);
293            }
294    
295            /**
296            * Deletes the template and its resources.
297            *
298            * @param templateId the primary key of the template to be deleted
299            * @throws PortalException if a portal exception occurred
300            */
301            @Override
302            public void deleteTemplate(long templateId)
303                    throws com.liferay.portal.kernel.exception.PortalException {
304                    _ddmTemplateLocalService.deleteTemplate(templateId);
305            }
306    
307            /**
308            * Deletes all the templates of the group.
309            *
310            * @param groupId the primary key of the group
311            * @throws PortalException if a portal exception occurred
312            */
313            @Override
314            public void deleteTemplates(long groupId)
315                    throws com.liferay.portal.kernel.exception.PortalException {
316                    _ddmTemplateLocalService.deleteTemplates(groupId);
317            }
318    
319            @Override
320            public void deleteTemplates(long groupId, long classNameId)
321                    throws com.liferay.portal.kernel.exception.PortalException {
322                    _ddmTemplateLocalService.deleteTemplates(groupId, classNameId);
323            }
324    
325            @Override
326            public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
327                    return _ddmTemplateLocalService.dynamicQuery();
328            }
329    
330            /**
331            * Performs a dynamic query on the database and returns the matching rows.
332            *
333            * @param dynamicQuery the dynamic query
334            * @return the matching rows
335            */
336            @Override
337            public <T> java.util.List<T> dynamicQuery(
338                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
339                    return _ddmTemplateLocalService.dynamicQuery(dynamicQuery);
340            }
341    
342            /**
343            * Performs a dynamic query on the database and returns a range of the matching rows.
344            *
345            * <p>
346            * 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.DDMTemplateModelImpl}. 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.
347            * </p>
348            *
349            * @param dynamicQuery the dynamic query
350            * @param start the lower bound of the range of model instances
351            * @param end the upper bound of the range of model instances (not inclusive)
352            * @return the range of matching rows
353            */
354            @Override
355            public <T> java.util.List<T> dynamicQuery(
356                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
357                    int end) {
358                    return _ddmTemplateLocalService.dynamicQuery(dynamicQuery, start, end);
359            }
360    
361            /**
362            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
363            *
364            * <p>
365            * 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.DDMTemplateModelImpl}. 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.
366            * </p>
367            *
368            * @param dynamicQuery the dynamic query
369            * @param start the lower bound of the range of model instances
370            * @param end the upper bound of the range of model instances (not inclusive)
371            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
372            * @return the ordered range of matching rows
373            */
374            @Override
375            public <T> java.util.List<T> dynamicQuery(
376                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
377                    int end,
378                    com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) {
379                    return _ddmTemplateLocalService.dynamicQuery(dynamicQuery, start, end,
380                            orderByComparator);
381            }
382    
383            /**
384            * Returns the number of rows matching the dynamic query.
385            *
386            * @param dynamicQuery the dynamic query
387            * @return the number of rows matching the dynamic query
388            */
389            @Override
390            public long dynamicQueryCount(
391                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
392                    return _ddmTemplateLocalService.dynamicQueryCount(dynamicQuery);
393            }
394    
395            /**
396            * Returns the number of rows matching the dynamic query.
397            *
398            * @param dynamicQuery the dynamic query
399            * @param projection the projection to apply to the query
400            * @return the number of rows matching the dynamic query
401            */
402            @Override
403            public long dynamicQueryCount(
404                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
405                    com.liferay.portal.kernel.dao.orm.Projection projection) {
406                    return _ddmTemplateLocalService.dynamicQueryCount(dynamicQuery,
407                            projection);
408            }
409    
410            @Override
411            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchDDMTemplate(
412                    long templateId) {
413                    return _ddmTemplateLocalService.fetchDDMTemplate(templateId);
414            }
415    
416            /**
417            * Returns the d d m template matching the UUID and group.
418            *
419            * @param uuid the d d m template's UUID
420            * @param groupId the primary key of the group
421            * @return the matching d d m template, or <code>null</code> if a matching d d m template could not be found
422            */
423            @Override
424            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchDDMTemplateByUuidAndGroupId(
425                    java.lang.String uuid, long groupId) {
426                    return _ddmTemplateLocalService.fetchDDMTemplateByUuidAndGroupId(uuid,
427                            groupId);
428            }
429    
430            /**
431            * Returns the template matching the group and template key.
432            *
433            * @param groupId the primary key of the group
434            * @param classNameId the primary key of the class name for the template's
435            related model
436            * @param templateKey the unique string identifying the template
437            * @return the matching template, or <code>null</code> if a matching
438            template could not be found
439            */
440            @Override
441            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchTemplate(
442                    long groupId, long classNameId, java.lang.String templateKey) {
443                    return _ddmTemplateLocalService.fetchTemplate(groupId, classNameId,
444                            templateKey);
445            }
446    
447            /**
448            * Returns the template matching the group and template key, optionally
449            * searching ancestor sites (that have sharing enabled) and global scoped
450            * sites.
451            *
452            * <p>
453            * This method first searches in the given group. If the template is still
454            * not found and <code>includeAncestorTemplates</code> is set to
455            * <code>true</code>, this method searches the group's ancestor sites (that
456            * have sharing enabled) and lastly searches global scoped sites.
457            * </p>
458            *
459            * @param groupId the primary key of the group
460            * @param classNameId the primary key of the class name for the template's
461            related model
462            * @param templateKey the unique string identifying the template
463            * @param includeAncestorTemplates whether to include ancestor sites (that
464            have sharing enabled) and include global scoped sites in the
465            search in the search
466            * @return the matching template, or <code>null</code> if a matching
467            template could not be found
468            * @throws PortalException if a portal exception occurred
469            */
470            @Override
471            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchTemplate(
472                    long groupId, long classNameId, java.lang.String templateKey,
473                    boolean includeAncestorTemplates)
474                    throws com.liferay.portal.kernel.exception.PortalException {
475                    return _ddmTemplateLocalService.fetchTemplate(groupId, classNameId,
476                            templateKey, includeAncestorTemplates);
477            }
478    
479            @Override
480            public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() {
481                    return _ddmTemplateLocalService.getActionableDynamicQuery();
482            }
483    
484            /**
485            * Returns the Spring bean ID for this bean.
486            *
487            * @return the Spring bean ID for this bean
488            */
489            @Override
490            public java.lang.String getBeanIdentifier() {
491                    return _ddmTemplateLocalService.getBeanIdentifier();
492            }
493    
494            /**
495            * Returns the d d m template with the primary key.
496            *
497            * @param templateId the primary key of the d d m template
498            * @return the d d m template
499            * @throws PortalException if a d d m template with the primary key could not be found
500            */
501            @Override
502            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate getDDMTemplate(
503                    long templateId)
504                    throws com.liferay.portal.kernel.exception.PortalException {
505                    return _ddmTemplateLocalService.getDDMTemplate(templateId);
506            }
507    
508            /**
509            * Returns the d d m template matching the UUID and group.
510            *
511            * @param uuid the d d m template's UUID
512            * @param groupId the primary key of the group
513            * @return the matching d d m template
514            * @throws PortalException if a matching d d m template could not be found
515            */
516            @Override
517            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate getDDMTemplateByUuidAndGroupId(
518                    java.lang.String uuid, long groupId)
519                    throws com.liferay.portal.kernel.exception.PortalException {
520                    return _ddmTemplateLocalService.getDDMTemplateByUuidAndGroupId(uuid,
521                            groupId);
522            }
523    
524            /**
525            * Returns a range of all the d d m templates.
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.DDMTemplateModelImpl}. 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 start the lower bound of the range of d d m templates
532            * @param end the upper bound of the range of d d m templates (not inclusive)
533            * @return the range of d d m templates
534            */
535            @Override
536            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getDDMTemplates(
537                    int start, int end) {
538                    return _ddmTemplateLocalService.getDDMTemplates(start, end);
539            }
540    
541            /**
542            * Returns all the d d m templates matching the UUID and company.
543            *
544            * @param uuid the UUID of the d d m templates
545            * @param companyId the primary key of the company
546            * @return the matching d d m templates, or an empty list if no matches were found
547            */
548            @Override
549            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getDDMTemplatesByUuidAndCompanyId(
550                    java.lang.String uuid, long companyId) {
551                    return _ddmTemplateLocalService.getDDMTemplatesByUuidAndCompanyId(uuid,
552                            companyId);
553            }
554    
555            /**
556            * Returns a range of d d m templates matching the UUID and company.
557            *
558            * @param uuid the UUID of the d d m templates
559            * @param companyId the primary key of the company
560            * @param start the lower bound of the range of d d m templates
561            * @param end the upper bound of the range of d d m templates (not inclusive)
562            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
563            * @return the range of matching d d m templates, or an empty list if no matches were found
564            */
565            @Override
566            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getDDMTemplatesByUuidAndCompanyId(
567                    java.lang.String uuid, long companyId, int start, int end,
568                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
569                    return _ddmTemplateLocalService.getDDMTemplatesByUuidAndCompanyId(uuid,
570                            companyId, start, end, orderByComparator);
571            }
572    
573            /**
574            * Returns the number of d d m templates.
575            *
576            * @return the number of d d m templates
577            */
578            @Override
579            public int getDDMTemplatesCount() {
580                    return _ddmTemplateLocalService.getDDMTemplatesCount();
581            }
582    
583            @Override
584            public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery(
585                    com.liferay.portal.kernel.lar.PortletDataContext portletDataContext) {
586                    return _ddmTemplateLocalService.getExportActionableDynamicQuery(portletDataContext);
587            }
588    
589            @Override
590            public com.liferay.portal.model.PersistedModel getPersistedModel(
591                    java.io.Serializable primaryKeyObj)
592                    throws com.liferay.portal.kernel.exception.PortalException {
593                    return _ddmTemplateLocalService.getPersistedModel(primaryKeyObj);
594            }
595    
596            /**
597            * Returns the template matching the group and template key.
598            *
599            * @param groupId the primary key of the group
600            * @param classNameId the primary key of the class name for the template's
601            related model
602            * @param templateKey the unique string identifying the template
603            * @return the matching template
604            * @throws PortalException if a matching template could not be found
605            */
606            @Override
607            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate getTemplate(
608                    long groupId, long classNameId, java.lang.String templateKey)
609                    throws com.liferay.portal.kernel.exception.PortalException {
610                    return _ddmTemplateLocalService.getTemplate(groupId, classNameId,
611                            templateKey);
612            }
613    
614            /**
615            * Returns the template matching the group and template key, optionally
616            * searching ancestor sites (that have sharing enabled) and global scoped
617            * sites.
618            *
619            * <p>
620            * This method first searches in the group. If the template is still not
621            * found and <code>includeAncestorTemplates</code> is set to
622            * <code>true</code>, this method searches the group's ancestor sites (that
623            * have sharing enabled) and lastly searches global scoped sites.
624            * </p>
625            *
626            * @param groupId the primary key of the group
627            * @param classNameId the primary key of the class name for the template's
628            related model
629            * @param templateKey the unique string identifying the template
630            * @param includeAncestorTemplates whether to include ancestor sites (that
631            have sharing enabled) and include global scoped sites in the
632            search in the search
633            * @return the matching template
634            * @throws PortalException if a matching template could not be found
635            */
636            @Override
637            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate getTemplate(
638                    long groupId, long classNameId, java.lang.String templateKey,
639                    boolean includeAncestorTemplates)
640                    throws com.liferay.portal.kernel.exception.PortalException {
641                    return _ddmTemplateLocalService.getTemplate(groupId, classNameId,
642                            templateKey, includeAncestorTemplates);
643            }
644    
645            /**
646            * Returns the template with the ID.
647            *
648            * @param templateId the primary key of the template
649            * @return the template with the ID
650            * @throws PortalException if a matching template could not be found
651            */
652            @Override
653            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate getTemplate(
654                    long templateId)
655                    throws com.liferay.portal.kernel.exception.PortalException {
656                    return _ddmTemplateLocalService.getTemplate(templateId);
657            }
658    
659            @Override
660            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate getTemplateBySmallImageId(
661                    long smallImageId)
662                    throws com.liferay.portal.kernel.exception.PortalException {
663                    return _ddmTemplateLocalService.getTemplateBySmallImageId(smallImageId);
664            }
665    
666            /**
667            * Returns all the templates with the class PK.
668            *
669            * @param classPK the primary key of the template's related entity
670            * @return the templates with the class PK
671            */
672            @Override
673            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
674                    long classPK) {
675                    return _ddmTemplateLocalService.getTemplates(classPK);
676            }
677    
678            /**
679            * Returns all the templates matching the group and class name ID.
680            *
681            * @param groupId the primary key of the group
682            * @param classNameId the primary key of the class name for the template's
683            related model
684            * @return the matching templates
685            */
686            @Override
687            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
688                    long groupId, long classNameId) {
689                    return _ddmTemplateLocalService.getTemplates(groupId, classNameId);
690            }
691    
692            /**
693            * Returns all the templates matching the group, class name ID, and class
694            * PK.
695            *
696            * @param groupId the primary key of the group
697            * @param classNameId the primary key of the class name for the template's
698            related model
699            * @param classPK the primary key of the template's related entity
700            * @return the matching templates
701            */
702            @Override
703            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
704                    long groupId, long classNameId, long classPK) {
705                    return _ddmTemplateLocalService.getTemplates(groupId, classNameId,
706                            classPK);
707            }
708    
709            @Override
710            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
711                    long groupId, long classNameId, long classPK,
712                    boolean includeAncestorTemplates)
713                    throws com.liferay.portal.kernel.exception.PortalException {
714                    return _ddmTemplateLocalService.getTemplates(groupId, classNameId,
715                            classPK, includeAncestorTemplates);
716            }
717    
718            /**
719            * Returns all the templates matching the group, class name ID, class PK,
720            * and type.
721            *
722            * @param groupId the primary key of the group
723            * @param classNameId the primary key of the class name for the template's
724            related model
725            * @param classPK the primary key of the template's related entity
726            * @param type the template's type. For more information, see {@link
727            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
728            * @return the matching templates
729            */
730            @Override
731            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
732                    long groupId, long classNameId, long classPK, java.lang.String type) {
733                    return _ddmTemplateLocalService.getTemplates(groupId, classNameId,
734                            classPK, type);
735            }
736    
737            /**
738            * Returns all the templates matching the group, class name ID, class PK,
739            * type, and mode.
740            *
741            * @param groupId the primary key of the group
742            * @param classNameId the primary key of the class name for the template's
743            related model
744            * @param classPK the primary key of the template's related entity
745            * @param type the template's type. For more information, see {@link
746            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
747            * @param mode the template's mode. For more information, see {@link
748            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
749            * @return the matching templates
750            */
751            @Override
752            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
753                    long groupId, long classNameId, long classPK, java.lang.String type,
754                    java.lang.String mode) {
755                    return _ddmTemplateLocalService.getTemplates(groupId, classNameId,
756                            classPK, type, mode);
757            }
758    
759            @Override
760            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
761                    long[] groupIds, long classNameId, long classPK) {
762                    return _ddmTemplateLocalService.getTemplates(groupIds, classNameId,
763                            classPK);
764            }
765    
766            @Override
767            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplatesByClassPK(
768                    long groupId, long classPK) {
769                    return _ddmTemplateLocalService.getTemplatesByClassPK(groupId, classPK);
770            }
771    
772            @Override
773            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplatesByClassPK(
774                    long groupId, long classPK, int start, int end) {
775                    return _ddmTemplateLocalService.getTemplatesByClassPK(groupId, classPK,
776                            start, end);
777            }
778    
779            @Override
780            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplatesByClassPK(
781                    long[] groupIds, long classPK) {
782                    return _ddmTemplateLocalService.getTemplatesByClassPK(groupIds, classPK);
783            }
784    
785            /**
786            * Returns the number of templates matching the group and class PK.
787            *
788            * @param groupId the primary key of the group
789            * @param classPK the primary key of the template's related entity
790            * @return the number of templates belonging to the group and class PK
791            */
792            @Override
793            public int getTemplatesByClassPKCount(long groupId, long classPK) {
794                    return _ddmTemplateLocalService.getTemplatesByClassPKCount(groupId,
795                            classPK);
796            }
797    
798            /**
799            * Returns an ordered range of all the templates matching the group and
800            * structure class name ID.
801            *
802            * <p>
803            * Useful when paginating results. Returns a maximum of <code>end -
804            * start</code> instances. <code>start</code> and <code>end</code> are not
805            * primary keys, they are indexes in the result set. Thus, <code>0</code>
806            * refers to the first result in the set. Setting both <code>start</code>
807            * and <code>end</code> to {@link
808            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
809            * result set.
810            * </p>
811            *
812            * @param groupId the primary key of the group
813            * @param structureClassNameId the primary key of the class name for the
814            template's related structure
815            * @param start the lower bound of the range of templates to return
816            * @param end the upper bound of the range of templates to return (not
817            inclusive)
818            * @param orderByComparator the comparator to order the templates
819            (optionally <code>null</code>)
820            * @return the range of matching templates ordered by the comparator
821            */
822            @Override
823            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplatesByStructureClassNameId(
824                    long groupId, long structureClassNameId, int start, int end,
825                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
826                    return _ddmTemplateLocalService.getTemplatesByStructureClassNameId(groupId,
827                            structureClassNameId, start, end, orderByComparator);
828            }
829    
830            /**
831            * Returns the number of templates matching the group and structure class
832            * name ID, including Generic Templates.
833            *
834            * @param groupId the primary key of the group
835            * @param structureClassNameId the primary key of the class name for the
836            template's related structure
837            * @return the number of matching templates
838            */
839            @Override
840            public int getTemplatesByStructureClassNameIdCount(long groupId,
841                    long structureClassNameId) {
842                    return _ddmTemplateLocalService.getTemplatesByStructureClassNameIdCount(groupId,
843                            structureClassNameId);
844            }
845    
846            /**
847            * Returns the number of templates belonging to the group.
848            *
849            * @param groupId the primary key of the group
850            * @return the number of templates belonging to the group
851            */
852            @Override
853            public int getTemplatesCount(long groupId) {
854                    return _ddmTemplateLocalService.getTemplatesCount(groupId);
855            }
856    
857            /**
858            * Returns the number of templates matching the group and class name ID.
859            *
860            * @param groupId the primary key of the group
861            * @param classNameId the primary key of the class name for the template's
862            related model
863            * @return the number of matching templates
864            */
865            @Override
866            public int getTemplatesCount(long groupId, long classNameId) {
867                    return _ddmTemplateLocalService.getTemplatesCount(groupId, classNameId);
868            }
869    
870            /**
871            * Returns the number of templates matching the group, class name ID, and
872            * class PK.
873            *
874            * @param groupId the primary key of the group
875            * @param classNameId the primary key of the class name for the template's
876            related model
877            * @param classPK the primary key of the template's related entity
878            * @return the number of matching templates
879            */
880            @Override
881            public int getTemplatesCount(long groupId, long classNameId, long classPK) {
882                    return _ddmTemplateLocalService.getTemplatesCount(groupId, classNameId,
883                            classPK);
884            }
885    
886            /**
887            * Returns an ordered range of all the templates matching the group, class
888            * name ID, class PK, type, and mode, and matching the keywords in the
889            * template names and descriptions.
890            *
891            * <p>
892            * Useful when paginating results. Returns a maximum of <code>end -
893            * start</code> instances. <code>start</code> and <code>end</code> are not
894            * primary keys, they are indexes in the result set. Thus, <code>0</code>
895            * refers to the first result in the set. Setting both <code>start</code>
896            * and <code>end</code> to {@link
897            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
898            * result set.
899            * </p>
900            *
901            * @param companyId the primary key of the template's company
902            * @param groupId the primary key of the group
903            * @param classNameId the primary key of the class name for the template's
904            related model
905            * @param classPK the primary key of the template's related entity
906            * @param keywords the keywords (space separated), which may occur in the
907            template's name or description (optionally <code>null</code>)
908            * @param type the template's type (optionally <code>null</code>). For more
909            information, see {@link
910            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
911            * @param mode the template's mode (optionally <code>null</code>). For more
912            information, see {@link
913            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
914            * @param start the lower bound of the range of templates to return
915            * @param end the upper bound of the range of templates to return (not
916            inclusive)
917            * @param orderByComparator the comparator to order the templates
918            (optionally <code>null</code>)
919            * @return the range of matching templates ordered by the comparator
920            */
921            @Override
922            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> search(
923                    long companyId, long groupId, long classNameId, long classPK,
924                    java.lang.String keywords, java.lang.String type,
925                    java.lang.String mode, int start, int end,
926                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
927                    return _ddmTemplateLocalService.search(companyId, groupId, classNameId,
928                            classPK, keywords, type, mode, start, end, orderByComparator);
929            }
930    
931            /**
932            * Returns an ordered range of all the templates matching the group, class
933            * name ID, class PK, name keyword, description keyword, type, mode, and
934            * language.
935            *
936            * <p>
937            * Useful when paginating results. Returns a maximum of <code>end -
938            * start</code> instances. <code>start</code> and <code>end</code> are not
939            * primary keys, they are indexes in the result set. Thus, <code>0</code>
940            * refers to the first result in the set. Setting both <code>start</code>
941            * and <code>end</code> to {@link
942            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
943            * result set.
944            * </p>
945            *
946            * @param companyId the primary key of the template's company
947            * @param groupId the primary key of the group
948            * @param classNameId the primary key of the class name for the template's
949            related model
950            * @param classPK the primary key of the template's related entity
951            * @param name the name keywords (optionally <code>null</code>)
952            * @param description the description keywords (optionally
953            <code>null</code>)
954            * @param type the template's type (optionally <code>null</code>). For more
955            information, see {@link
956            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
957            * @param mode the template's mode (optionally <code>null</code>). For more
958            information, see {@link
959            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
960            * @param language the template's script language (optionally
961            <code>null</code>). For more information, see {@link
962            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
963            * @param andOperator whether every field must match its keywords, or just
964            one field
965            * @param start the lower bound of the range of templates to return
966            * @param end the upper bound of the range of templates to return (not
967            inclusive)
968            * @param orderByComparator the comparator to order the templates
969            (optionally <code>null</code>)
970            * @return the range of matching templates ordered by the comparator
971            */
972            @Override
973            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> search(
974                    long companyId, long groupId, long classNameId, long classPK,
975                    java.lang.String name, java.lang.String description,
976                    java.lang.String type, java.lang.String mode,
977                    java.lang.String language, boolean andOperator, int start, int end,
978                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
979                    return _ddmTemplateLocalService.search(companyId, groupId, classNameId,
980                            classPK, name, description, type, mode, language, andOperator,
981                            start, end, orderByComparator);
982            }
983    
984            /**
985            * Returns an ordered range of all the templates matching the group IDs,
986            * class Name IDs, class PK, type, and mode, and include the keywords on its
987            * names and descriptions.
988            *
989            * <p>
990            * Useful when paginating results. Returns a maximum of <code>end -
991            * start</code> instances. <code>start</code> and <code>end</code> are not
992            * primary keys, they are indexes in the result set. Thus, <code>0</code>
993            * refers to the first result in the set. Setting both <code>start</code>
994            * and <code>end</code> to {@link
995            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
996            * result set.
997            * </p>
998            *
999            * @param companyId the primary key of the template's company
1000            * @param groupIds the primary keys of the groups
1001            * @param classNameIds the primary keys of the entity's instances the
1002            templates are related to
1003            * @param classPKs the primary keys of the template's related entities
1004            * @param keywords the keywords (space separated), which may occur in the
1005            template's name or description (optionally <code>null</code>)
1006            * @param type the template's type (optionally <code>null</code>). For more
1007            information, see {@link
1008            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1009            * @param mode the template's mode (optionally <code>null</code>). For more
1010            information, see {@link
1011            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1012            * @param start the lower bound of the range of templates to return
1013            * @param end the upper bound of the range of templates to return (not
1014            inclusive)
1015            * @param orderByComparator the comparator to order the templates
1016            (optionally <code>null</code>)
1017            * @return the range of matching templates ordered by the comparator
1018            */
1019            @Override
1020            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> search(
1021                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
1022                    java.lang.String keywords, java.lang.String type,
1023                    java.lang.String mode, int start, int end,
1024                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
1025                    return _ddmTemplateLocalService.search(companyId, groupIds,
1026                            classNameIds, classPKs, keywords, type, mode, start, end,
1027                            orderByComparator);
1028            }
1029    
1030            /**
1031            * Returns an ordered range of all the templates matching the group IDs,
1032            * class name IDs, class PK, name keyword, description keyword, type, mode,
1033            * and language.
1034            *
1035            * <p>
1036            * Useful when paginating results. Returns a maximum of <code>end -
1037            * start</code> instances. <code>start</code> and <code>end</code> are not
1038            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1039            * refers to the first result in the set. Setting both <code>start</code>
1040            * and <code>end</code> to {@link
1041            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1042            * result set.
1043            * </p>
1044            *
1045            * @param companyId the primary key of the template's company
1046            * @param groupIds the primary keys of the groups
1047            * @param classNameIds the primary keys of the entity's instances the
1048            templates are related to
1049            * @param classPKs the primary keys of the template's related entities
1050            * @param name the name keywords (optionally <code>null</code>)
1051            * @param description the description keywords (optionally
1052            <code>null</code>)
1053            * @param type the template's type (optionally <code>null</code>). For more
1054            information, see {@link
1055            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1056            * @param mode the template's mode (optionally <code>null</code>). For more
1057            information, see {@link
1058            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1059            * @param language the template's script language (optionally
1060            <code>null</code>). For more information, see {@link
1061            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1062            * @param andOperator whether every field must match its keywords, or just
1063            one field.
1064            * @param start the lower bound of the range of templates to return
1065            * @param end the upper bound of the range of templates to return (not
1066            inclusive)
1067            * @param orderByComparator the comparator to order the templates
1068            (optionally <code>null</code>)
1069            * @return the range of matching templates ordered by the comparator
1070            */
1071            @Override
1072            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> search(
1073                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
1074                    java.lang.String name, java.lang.String description,
1075                    java.lang.String type, java.lang.String mode,
1076                    java.lang.String language, boolean andOperator, int start, int end,
1077                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
1078                    return _ddmTemplateLocalService.search(companyId, groupIds,
1079                            classNameIds, classPKs, name, description, type, mode, language,
1080                            andOperator, start, end, orderByComparator);
1081            }
1082    
1083            /**
1084            * Returns the number of templates matching the group, class name ID, class
1085            * PK, type, and matching the keywords in the template names and
1086            * descriptions.
1087            *
1088            * @param companyId the primary key of the template's company
1089            * @param groupId the primary key of the group
1090            * @param classNameId the primary key of the class name for the template's
1091            related model
1092            * @param classPK the primary key of the template's related entity
1093            * @param keywords the keywords (space separated), which may occur in the
1094            template's name or description (optionally <code>null</code>)
1095            * @param type the template's type (optionally <code>null</code>). For more
1096            information, see {@link
1097            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1098            * @param mode the template's mode (optionally <code>null</code>). For more
1099            information, see {@link
1100            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1101            * @return the number of matching templates
1102            */
1103            @Override
1104            public int searchCount(long companyId, long groupId, long classNameId,
1105                    long classPK, java.lang.String keywords, java.lang.String type,
1106                    java.lang.String mode) {
1107                    return _ddmTemplateLocalService.searchCount(companyId, groupId,
1108                            classNameId, classPK, keywords, type, mode);
1109            }
1110    
1111            /**
1112            * Returns the number of templates matching the group, class name ID, class
1113            * PK, name keyword, description keyword, type, mode, and language.
1114            *
1115            * @param companyId the primary key of the template's company
1116            * @param groupId the primary key of the group
1117            * @param classNameId the primary key of the class name for the template's
1118            related model
1119            * @param classPK the primary key of the template's related entity
1120            * @param name the name keywords (optionally <code>null</code>)
1121            * @param description the description keywords (optionally
1122            <code>null</code>)
1123            * @param type the template's type (optionally <code>null</code>). For more
1124            information, see {@link
1125            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1126            * @param mode the template's mode (optionally <code>null</code>). For more
1127            information, see {@link
1128            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1129            * @param language the template's script language (optionally
1130            <code>null</code>). For more information, see {@link
1131            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1132            * @param andOperator whether every field must match its keywords, or just
1133            one field.
1134            * @return the number of matching templates
1135            */
1136            @Override
1137            public int searchCount(long companyId, long groupId, long classNameId,
1138                    long classPK, java.lang.String name, java.lang.String description,
1139                    java.lang.String type, java.lang.String mode,
1140                    java.lang.String language, boolean andOperator) {
1141                    return _ddmTemplateLocalService.searchCount(companyId, groupId,
1142                            classNameId, classPK, name, description, type, mode, language,
1143                            andOperator);
1144            }
1145    
1146            /**
1147            * Returns the number of templates matching the group IDs, class name IDs,
1148            * class PK, type, and mode, and matching the keywords in the template names
1149            * and descriptions.
1150            *
1151            * @param companyId the primary key of the template's company
1152            * @param groupIds the primary keys of the groups
1153            * @param classNameIds the primary keys of the entity's instance the
1154            templates are related to
1155            * @param classPKs the primary keys of the template's related entities
1156            * @param keywords the keywords (space separated), which may occur in the
1157            template's name or description (optionally <code>null</code>)
1158            * @param type the template's type (optionally <code>null</code>). For more
1159            information, see {@link
1160            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1161            * @param mode the template's mode (optionally <code>null</code>). For more
1162            information, see {@link
1163            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1164            * @return the number of matching templates
1165            */
1166            @Override
1167            public int searchCount(long companyId, long[] groupIds,
1168                    long[] classNameIds, long[] classPKs, java.lang.String keywords,
1169                    java.lang.String type, java.lang.String mode) {
1170                    return _ddmTemplateLocalService.searchCount(companyId, groupIds,
1171                            classNameIds, classPKs, keywords, type, mode);
1172            }
1173    
1174            /**
1175            * Returns the number of templates matching the group IDs, class name IDs,
1176            * class PKs, name keyword, description keyword, type, mode, and language.
1177            *
1178            * @param companyId the primary key of the templates company
1179            * @param groupIds the primary keys of the groups
1180            * @param classNameIds the primary keys of the entity's instance the
1181            templates are related to
1182            * @param classPKs the primary keys of the template's related entities
1183            * @param name the name keywords (optionally <code>null</code>)
1184            * @param description the description keywords (optionally
1185            <code>null</code>)
1186            * @param type the template's type (optionally <code>null</code>). For more
1187            information, see {@link
1188            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1189            * @param mode the template's mode (optionally <code>null</code>). For more
1190            information, see {@link
1191            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1192            * @param language the template's script language (optionally
1193            <code>null</code>). For more information, see {@link
1194            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1195            * @param andOperator whether every field must match its keywords, or just
1196            one field.
1197            * @return the number of matching templates
1198            */
1199            @Override
1200            public int searchCount(long companyId, long[] groupIds,
1201                    long[] classNameIds, long[] classPKs, java.lang.String name,
1202                    java.lang.String description, java.lang.String type,
1203                    java.lang.String mode, java.lang.String language, boolean andOperator) {
1204                    return _ddmTemplateLocalService.searchCount(companyId, groupIds,
1205                            classNameIds, classPKs, name, description, type, mode, language,
1206                            andOperator);
1207            }
1208    
1209            /**
1210            * Sets the Spring bean ID for this bean.
1211            *
1212            * @param beanIdentifier the Spring bean ID for this bean
1213            */
1214            @Override
1215            public void setBeanIdentifier(java.lang.String beanIdentifier) {
1216                    _ddmTemplateLocalService.setBeanIdentifier(beanIdentifier);
1217            }
1218    
1219            /**
1220            * Updates the d d m template in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
1221            *
1222            * @param ddmTemplate the d d m template
1223            * @return the d d m template that was updated
1224            */
1225            @Override
1226            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate updateDDMTemplate(
1227                    com.liferay.portlet.dynamicdatamapping.model.DDMTemplate ddmTemplate) {
1228                    return _ddmTemplateLocalService.updateDDMTemplate(ddmTemplate);
1229            }
1230    
1231            /**
1232            * Updates the template matching the ID.
1233            *
1234            * @param templateId the primary key of the template
1235            * @param classPK the primary key of the template's related entity
1236            * @param nameMap the template's new locales and localized names
1237            * @param descriptionMap the template's new locales and localized
1238            description
1239            * @param type the template's type. For more information, see {@link
1240            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1241            * @param mode the template's mode. For more information, see {@link
1242            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1243            * @param language the template's script language. For more information,
1244            see {@link
1245            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1246            * @param script the template's script
1247            * @param cacheable whether the template is cacheable
1248            * @param serviceContext the service context to be applied. Can set the
1249            modification date.
1250            * @return the updated template
1251            * @throws PortalException if a portal exception occurred
1252            */
1253            @Override
1254            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate updateTemplate(
1255                    long templateId, long classPK,
1256                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1257                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1258                    java.lang.String type, java.lang.String mode,
1259                    java.lang.String language, java.lang.String script, boolean cacheable,
1260                    com.liferay.portal.service.ServiceContext serviceContext)
1261                    throws com.liferay.portal.kernel.exception.PortalException {
1262                    return _ddmTemplateLocalService.updateTemplate(templateId, classPK,
1263                            nameMap, descriptionMap, type, mode, language, script, cacheable,
1264                            serviceContext);
1265            }
1266    
1267            /**
1268            * Updates the template matching the ID.
1269            *
1270            * @param templateId the primary key of the template
1271            * @param classPK the primary key of the template's related entity
1272            * @param nameMap the template's new locales and localized names
1273            * @param descriptionMap the template's new locales and localized
1274            description
1275            * @param type the template's type. For more information, see {@link
1276            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1277            * @param mode the template's mode. For more information, see {@link
1278            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1279            * @param language the template's script language. For more information,
1280            see {@link
1281            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1282            * @param script the template's script
1283            * @param cacheable whether the template is cacheable
1284            * @param smallImage whether the template has a small image
1285            * @param smallImageURL the template's small image URL (optionally
1286            <code>null</code>)
1287            * @param smallImageFile the template's small image file (optionally
1288            <code>null</code>)
1289            * @param serviceContext the service context to be applied. Can set the
1290            modification date.
1291            * @return the updated template
1292            * @throws PortalException if a portal exception occurred
1293            */
1294            @Override
1295            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate updateTemplate(
1296                    long templateId, long classPK,
1297                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1298                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1299                    java.lang.String type, java.lang.String mode,
1300                    java.lang.String language, java.lang.String script, boolean cacheable,
1301                    boolean smallImage, java.lang.String smallImageURL,
1302                    java.io.File smallImageFile,
1303                    com.liferay.portal.service.ServiceContext serviceContext)
1304                    throws com.liferay.portal.kernel.exception.PortalException {
1305                    return _ddmTemplateLocalService.updateTemplate(templateId, classPK,
1306                            nameMap, descriptionMap, type, mode, language, script, cacheable,
1307                            smallImage, smallImageURL, smallImageFile, serviceContext);
1308            }
1309    
1310            /**
1311             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
1312             */
1313            @Deprecated
1314            public DDMTemplateLocalService getWrappedDDMTemplateLocalService() {
1315                    return _ddmTemplateLocalService;
1316            }
1317    
1318            /**
1319             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
1320             */
1321            @Deprecated
1322            public void setWrappedDDMTemplateLocalService(
1323                    DDMTemplateLocalService ddmTemplateLocalService) {
1324                    _ddmTemplateLocalService = ddmTemplateLocalService;
1325            }
1326    
1327            @Override
1328            public DDMTemplateLocalService getWrappedService() {
1329                    return _ddmTemplateLocalService;
1330            }
1331    
1332            @Override
1333            public void setWrappedService(
1334                    DDMTemplateLocalService ddmTemplateLocalService) {
1335                    _ddmTemplateLocalService = ddmTemplateLocalService;
1336            }
1337    
1338            private DDMTemplateLocalService _ddmTemplateLocalService;
1339    }