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