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 that match the dynamic query.
385            *
386            * @param dynamicQuery the dynamic query
387            * @return the number of rows that match 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 that match 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 that match 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            @Override
542            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getDDMTemplatesByUuidAndCompanyId(
543                    java.lang.String uuid, long companyId) {
544                    return _ddmTemplateLocalService.getDDMTemplatesByUuidAndCompanyId(uuid,
545                            companyId);
546            }
547    
548            @Override
549            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getDDMTemplatesByUuidAndCompanyId(
550                    java.lang.String uuid, long companyId, int start, int end,
551                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
552                    return _ddmTemplateLocalService.getDDMTemplatesByUuidAndCompanyId(uuid,
553                            companyId, start, end, orderByComparator);
554            }
555    
556            /**
557            * Returns the number of d d m templates.
558            *
559            * @return the number of d d m templates
560            */
561            @Override
562            public int getDDMTemplatesCount() {
563                    return _ddmTemplateLocalService.getDDMTemplatesCount();
564            }
565    
566            @Override
567            public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery(
568                    com.liferay.portal.kernel.lar.PortletDataContext portletDataContext) {
569                    return _ddmTemplateLocalService.getExportActionableDynamicQuery(portletDataContext);
570            }
571    
572            @Override
573            public com.liferay.portal.model.PersistedModel getPersistedModel(
574                    java.io.Serializable primaryKeyObj)
575                    throws com.liferay.portal.kernel.exception.PortalException {
576                    return _ddmTemplateLocalService.getPersistedModel(primaryKeyObj);
577            }
578    
579            /**
580            * Returns the template matching the group and template key.
581            *
582            * @param groupId the primary key of the group
583            * @param classNameId the primary key of the class name for the template's
584            related model
585            * @param templateKey the unique string identifying the template
586            * @return the matching template
587            * @throws PortalException if a matching template could not be found
588            */
589            @Override
590            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate getTemplate(
591                    long groupId, long classNameId, java.lang.String templateKey)
592                    throws com.liferay.portal.kernel.exception.PortalException {
593                    return _ddmTemplateLocalService.getTemplate(groupId, classNameId,
594                            templateKey);
595            }
596    
597            /**
598            * Returns the template matching the group and template key, optionally
599            * searching ancestor sites (that have sharing enabled) and global scoped
600            * sites.
601            *
602            * <p>
603            * This method first searches in the group. If the template is still not
604            * found and <code>includeAncestorTemplates</code> is set to
605            * <code>true</code>, this method searches the group's ancestor sites (that
606            * have sharing enabled) and lastly searches global scoped sites.
607            * </p>
608            *
609            * @param groupId the primary key of the group
610            * @param classNameId the primary key of the class name for the template's
611            related model
612            * @param templateKey the unique string identifying the template
613            * @param includeAncestorTemplates whether to include ancestor sites (that
614            have sharing enabled) and include global scoped sites in the
615            search in the search
616            * @return the matching template
617            * @throws PortalException if a matching template could not be found
618            */
619            @Override
620            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate getTemplate(
621                    long groupId, long classNameId, java.lang.String templateKey,
622                    boolean includeAncestorTemplates)
623                    throws com.liferay.portal.kernel.exception.PortalException {
624                    return _ddmTemplateLocalService.getTemplate(groupId, classNameId,
625                            templateKey, includeAncestorTemplates);
626            }
627    
628            /**
629            * Returns the template with the ID.
630            *
631            * @param templateId the primary key of the template
632            * @return the template with the ID
633            * @throws PortalException if a matching template could not be found
634            */
635            @Override
636            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate getTemplate(
637                    long templateId)
638                    throws com.liferay.portal.kernel.exception.PortalException {
639                    return _ddmTemplateLocalService.getTemplate(templateId);
640            }
641    
642            @Override
643            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate getTemplateBySmallImageId(
644                    long smallImageId)
645                    throws com.liferay.portal.kernel.exception.PortalException {
646                    return _ddmTemplateLocalService.getTemplateBySmallImageId(smallImageId);
647            }
648    
649            /**
650            * Returns all the templates with the class PK.
651            *
652            * @param classPK the primary key of the template's related entity
653            * @return the templates with the class PK
654            */
655            @Override
656            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
657                    long classPK) {
658                    return _ddmTemplateLocalService.getTemplates(classPK);
659            }
660    
661            /**
662            * Returns all the templates matching the group and class name ID.
663            *
664            * @param groupId the primary key of the group
665            * @param classNameId the primary key of the class name for the template's
666            related model
667            * @return the matching templates
668            */
669            @Override
670            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
671                    long groupId, long classNameId) {
672                    return _ddmTemplateLocalService.getTemplates(groupId, classNameId);
673            }
674    
675            /**
676            * Returns all the templates matching the group, class name ID, and class
677            * PK.
678            *
679            * @param groupId the primary key of the group
680            * @param classNameId the primary key of the class name for the template's
681            related model
682            * @param classPK the primary key of the template's related entity
683            * @return the matching templates
684            */
685            @Override
686            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
687                    long groupId, long classNameId, long classPK) {
688                    return _ddmTemplateLocalService.getTemplates(groupId, classNameId,
689                            classPK);
690            }
691    
692            @Override
693            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
694                    long groupId, long classNameId, long classPK,
695                    boolean includeAncestorTemplates)
696                    throws com.liferay.portal.kernel.exception.PortalException {
697                    return _ddmTemplateLocalService.getTemplates(groupId, classNameId,
698                            classPK, includeAncestorTemplates);
699            }
700    
701            /**
702            * Returns all the templates matching the group, class name ID, class PK,
703            * and type.
704            *
705            * @param groupId the primary key of the group
706            * @param classNameId the primary key of the class name for the template's
707            related model
708            * @param classPK the primary key of the template's related entity
709            * @param type the template's type. For more information, see {@link
710            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
711            * @return the matching templates
712            */
713            @Override
714            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
715                    long groupId, long classNameId, long classPK, java.lang.String type) {
716                    return _ddmTemplateLocalService.getTemplates(groupId, classNameId,
717                            classPK, type);
718            }
719    
720            /**
721            * Returns all the templates matching the group, class name ID, class PK,
722            * type, and mode.
723            *
724            * @param groupId the primary key of the group
725            * @param classNameId the primary key of the class name for the template's
726            related model
727            * @param classPK the primary key of the template's related entity
728            * @param type the template's type. For more information, see {@link
729            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
730            * @param mode the template's mode. For more information, see {@link
731            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
732            * @return the matching templates
733            */
734            @Override
735            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
736                    long groupId, long classNameId, long classPK, java.lang.String type,
737                    java.lang.String mode) {
738                    return _ddmTemplateLocalService.getTemplates(groupId, classNameId,
739                            classPK, type, mode);
740            }
741    
742            @Override
743            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplates(
744                    long[] groupIds, long classNameId, long classPK) {
745                    return _ddmTemplateLocalService.getTemplates(groupIds, classNameId,
746                            classPK);
747            }
748    
749            @Override
750            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplatesByClassPK(
751                    long groupId, long classPK) {
752                    return _ddmTemplateLocalService.getTemplatesByClassPK(groupId, classPK);
753            }
754    
755            @Override
756            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplatesByClassPK(
757                    long groupId, long classPK, int start, int end) {
758                    return _ddmTemplateLocalService.getTemplatesByClassPK(groupId, classPK,
759                            start, end);
760            }
761    
762            @Override
763            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplatesByClassPK(
764                    long[] groupIds, long classPK) {
765                    return _ddmTemplateLocalService.getTemplatesByClassPK(groupIds, classPK);
766            }
767    
768            /**
769            * Returns the number of templates matching the group and class PK.
770            *
771            * @param groupId the primary key of the group
772            * @param classPK the primary key of the template's related entity
773            * @return the number of templates belonging to the group and class PK
774            */
775            @Override
776            public int getTemplatesByClassPKCount(long groupId, long classPK) {
777                    return _ddmTemplateLocalService.getTemplatesByClassPKCount(groupId,
778                            classPK);
779            }
780    
781            /**
782            * Returns an ordered range of all the templates matching the group and
783            * structure class name ID.
784            *
785            * <p>
786            * Useful when paginating results. Returns a maximum of <code>end -
787            * start</code> instances. <code>start</code> and <code>end</code> are not
788            * primary keys, they are indexes in the result set. Thus, <code>0</code>
789            * refers to the first result in the set. Setting both <code>start</code>
790            * and <code>end</code> to {@link
791            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
792            * result set.
793            * </p>
794            *
795            * @param groupId the primary key of the group
796            * @param structureClassNameId the primary key of the class name for the
797            template's related structure
798            * @param start the lower bound of the range of templates to return
799            * @param end the upper bound of the range of templates to return (not
800            inclusive)
801            * @param orderByComparator the comparator to order the templates
802            (optionally <code>null</code>)
803            * @return the range of matching templates ordered by the comparator
804            */
805            @Override
806            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> getTemplatesByStructureClassNameId(
807                    long groupId, long structureClassNameId, int start, int end,
808                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
809                    return _ddmTemplateLocalService.getTemplatesByStructureClassNameId(groupId,
810                            structureClassNameId, start, end, orderByComparator);
811            }
812    
813            /**
814            * Returns the number of templates matching the group and structure class
815            * name ID, including Generic Templates.
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            * @return the number of matching templates
821            */
822            @Override
823            public int getTemplatesByStructureClassNameIdCount(long groupId,
824                    long structureClassNameId) {
825                    return _ddmTemplateLocalService.getTemplatesByStructureClassNameIdCount(groupId,
826                            structureClassNameId);
827            }
828    
829            /**
830            * Returns the number of templates belonging to the group.
831            *
832            * @param groupId the primary key of the group
833            * @return the number of templates belonging to the group
834            */
835            @Override
836            public int getTemplatesCount(long groupId) {
837                    return _ddmTemplateLocalService.getTemplatesCount(groupId);
838            }
839    
840            /**
841            * Returns the number of templates matching the group and class name ID.
842            *
843            * @param groupId the primary key of the group
844            * @param classNameId the primary key of the class name for the template's
845            related model
846            * @return the number of matching templates
847            */
848            @Override
849            public int getTemplatesCount(long groupId, long classNameId) {
850                    return _ddmTemplateLocalService.getTemplatesCount(groupId, classNameId);
851            }
852    
853            /**
854            * Returns the number of templates matching the group, class name ID, and
855            * class PK.
856            *
857            * @param groupId the primary key of the group
858            * @param classNameId the primary key of the class name for the template's
859            related model
860            * @param classPK the primary key of the template's related entity
861            * @return the number of matching templates
862            */
863            @Override
864            public int getTemplatesCount(long groupId, long classNameId, long classPK) {
865                    return _ddmTemplateLocalService.getTemplatesCount(groupId, classNameId,
866                            classPK);
867            }
868    
869            /**
870            * Returns an ordered range of all the templates matching the group, class
871            * name ID, class PK, type, and mode, and matching the keywords in the
872            * template names and descriptions.
873            *
874            * <p>
875            * Useful when paginating results. Returns a maximum of <code>end -
876            * start</code> instances. <code>start</code> and <code>end</code> are not
877            * primary keys, they are indexes in the result set. Thus, <code>0</code>
878            * refers to the first result in the set. Setting both <code>start</code>
879            * and <code>end</code> to {@link
880            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
881            * result set.
882            * </p>
883            *
884            * @param companyId the primary key of the template's company
885            * @param groupId the primary key of the group
886            * @param classNameId the primary key of the class name for the template's
887            related model
888            * @param classPK the primary key of the template's related entity
889            * @param keywords the keywords (space separated), which may occur in the
890            template's name or description (optionally <code>null</code>)
891            * @param type the template's type (optionally <code>null</code>). For more
892            information, see {@link
893            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
894            * @param mode the template's mode (optionally <code>null</code>). For more
895            information, see {@link
896            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
897            * @param start the lower bound of the range of templates to return
898            * @param end the upper bound of the range of templates to return (not
899            inclusive)
900            * @param orderByComparator the comparator to order the templates
901            (optionally <code>null</code>)
902            * @return the range of matching templates ordered by the comparator
903            */
904            @Override
905            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> search(
906                    long companyId, long groupId, long classNameId, long classPK,
907                    java.lang.String keywords, java.lang.String type,
908                    java.lang.String mode, int start, int end,
909                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
910                    return _ddmTemplateLocalService.search(companyId, groupId, classNameId,
911                            classPK, keywords, type, mode, start, end, orderByComparator);
912            }
913    
914            /**
915            * Returns an ordered range of all the templates matching the group, class
916            * name ID, class PK, name keyword, description keyword, type, mode, and
917            * language.
918            *
919            * <p>
920            * Useful when paginating results. Returns a maximum of <code>end -
921            * start</code> instances. <code>start</code> and <code>end</code> are not
922            * primary keys, they are indexes in the result set. Thus, <code>0</code>
923            * refers to the first result in the set. Setting both <code>start</code>
924            * and <code>end</code> to {@link
925            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
926            * result set.
927            * </p>
928            *
929            * @param companyId the primary key of the template's company
930            * @param groupId the primary key of the group
931            * @param classNameId the primary key of the class name for the template's
932            related model
933            * @param classPK the primary key of the template's related entity
934            * @param name the name keywords (optionally <code>null</code>)
935            * @param description the description keywords (optionally
936            <code>null</code>)
937            * @param type the template's type (optionally <code>null</code>). For more
938            information, see {@link
939            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
940            * @param mode the template's mode (optionally <code>null</code>). For more
941            information, see {@link
942            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
943            * @param language the template's script language (optionally
944            <code>null</code>). For more information, see {@link
945            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
946            * @param andOperator whether every field must match its keywords, or just
947            one field
948            * @param start the lower bound of the range of templates to return
949            * @param end the upper bound of the range of templates to return (not
950            inclusive)
951            * @param orderByComparator the comparator to order the templates
952            (optionally <code>null</code>)
953            * @return the range of matching templates ordered by the comparator
954            */
955            @Override
956            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> search(
957                    long companyId, long groupId, long classNameId, long classPK,
958                    java.lang.String name, java.lang.String description,
959                    java.lang.String type, java.lang.String mode,
960                    java.lang.String language, boolean andOperator, int start, int end,
961                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
962                    return _ddmTemplateLocalService.search(companyId, groupId, classNameId,
963                            classPK, name, description, type, mode, language, andOperator,
964                            start, end, orderByComparator);
965            }
966    
967            /**
968            * Returns an ordered range of all the templates matching the group IDs,
969            * class Name IDs, class PK, type, and mode, and include the keywords on its
970            * names and descriptions.
971            *
972            * <p>
973            * Useful when paginating results. Returns a maximum of <code>end -
974            * start</code> instances. <code>start</code> and <code>end</code> are not
975            * primary keys, they are indexes in the result set. Thus, <code>0</code>
976            * refers to the first result in the set. Setting both <code>start</code>
977            * and <code>end</code> to {@link
978            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
979            * result set.
980            * </p>
981            *
982            * @param companyId the primary key of the template's company
983            * @param groupIds the primary keys of the groups
984            * @param classNameIds the primary keys of the entity's instances the
985            templates are related to
986            * @param classPKs the primary keys of the template's related entities
987            * @param keywords the keywords (space separated), which may occur in the
988            template's name or description (optionally <code>null</code>)
989            * @param type the template's type (optionally <code>null</code>). For more
990            information, see {@link
991            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
992            * @param mode the template's mode (optionally <code>null</code>). For more
993            information, see {@link
994            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
995            * @param start the lower bound of the range of templates to return
996            * @param end the upper bound of the range of templates to return (not
997            inclusive)
998            * @param orderByComparator the comparator to order the templates
999            (optionally <code>null</code>)
1000            * @return the range of matching templates ordered by the comparator
1001            */
1002            @Override
1003            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> search(
1004                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
1005                    java.lang.String keywords, java.lang.String type,
1006                    java.lang.String mode, int start, int end,
1007                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
1008                    return _ddmTemplateLocalService.search(companyId, groupIds,
1009                            classNameIds, classPKs, keywords, type, mode, start, end,
1010                            orderByComparator);
1011            }
1012    
1013            /**
1014            * Returns an ordered range of all the templates matching the group IDs,
1015            * class name IDs, class PK, name keyword, description keyword, type, mode,
1016            * and language.
1017            *
1018            * <p>
1019            * Useful when paginating results. Returns a maximum of <code>end -
1020            * start</code> instances. <code>start</code> and <code>end</code> are not
1021            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1022            * refers to the first result in the set. Setting both <code>start</code>
1023            * and <code>end</code> to {@link
1024            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1025            * result set.
1026            * </p>
1027            *
1028            * @param companyId the primary key of the template's company
1029            * @param groupIds the primary keys of the groups
1030            * @param classNameIds the primary keys of the entity's instances the
1031            templates are related to
1032            * @param classPKs the primary keys of the template's related entities
1033            * @param name the name keywords (optionally <code>null</code>)
1034            * @param description the description keywords (optionally
1035            <code>null</code>)
1036            * @param type the template's type (optionally <code>null</code>). For more
1037            information, see {@link
1038            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1039            * @param mode the template's mode (optionally <code>null</code>). For more
1040            information, see {@link
1041            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1042            * @param language the template's script language (optionally
1043            <code>null</code>). For more information, see {@link
1044            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1045            * @param andOperator whether every field must match its keywords, or just
1046            one field.
1047            * @param start the lower bound of the range of templates to return
1048            * @param end the upper bound of the range of templates to return (not
1049            inclusive)
1050            * @param orderByComparator the comparator to order the templates
1051            (optionally <code>null</code>)
1052            * @return the range of matching templates ordered by the comparator
1053            */
1054            @Override
1055            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> search(
1056                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
1057                    java.lang.String name, java.lang.String description,
1058                    java.lang.String type, java.lang.String mode,
1059                    java.lang.String language, boolean andOperator, int start, int end,
1060                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> orderByComparator) {
1061                    return _ddmTemplateLocalService.search(companyId, groupIds,
1062                            classNameIds, classPKs, name, description, type, mode, language,
1063                            andOperator, start, end, orderByComparator);
1064            }
1065    
1066            /**
1067            * Returns the number of templates matching the group, class name ID, class
1068            * PK, type, and matching the keywords in the template names and
1069            * descriptions.
1070            *
1071            * @param companyId the primary key of the template's company
1072            * @param groupId the primary key of the group
1073            * @param classNameId the primary key of the class name for the template's
1074            related model
1075            * @param classPK the primary key of the template's related entity
1076            * @param keywords the keywords (space separated), which may occur in the
1077            template's name or description (optionally <code>null</code>)
1078            * @param type the template's type (optionally <code>null</code>). For more
1079            information, see {@link
1080            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1081            * @param mode the template's mode (optionally <code>null</code>). For more
1082            information, see {@link
1083            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1084            * @return the number of matching templates
1085            */
1086            @Override
1087            public int searchCount(long companyId, long groupId, long classNameId,
1088                    long classPK, java.lang.String keywords, java.lang.String type,
1089                    java.lang.String mode) {
1090                    return _ddmTemplateLocalService.searchCount(companyId, groupId,
1091                            classNameId, classPK, keywords, type, mode);
1092            }
1093    
1094            /**
1095            * Returns the number of templates matching the group, class name ID, class
1096            * PK, name keyword, description keyword, type, mode, and language.
1097            *
1098            * @param companyId the primary key of the template's company
1099            * @param groupId the primary key of the group
1100            * @param classNameId the primary key of the class name for the template's
1101            related model
1102            * @param classPK the primary key of the template's related entity
1103            * @param name the name keywords (optionally <code>null</code>)
1104            * @param description the description keywords (optionally
1105            <code>null</code>)
1106            * @param type the template's type (optionally <code>null</code>). For more
1107            information, see {@link
1108            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1109            * @param mode the template's mode (optionally <code>null</code>). For more
1110            information, see {@link
1111            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1112            * @param language the template's script language (optionally
1113            <code>null</code>). For more information, see {@link
1114            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1115            * @param andOperator whether every field must match its keywords, or just
1116            one field.
1117            * @return the number of matching templates
1118            */
1119            @Override
1120            public int searchCount(long companyId, long groupId, long classNameId,
1121                    long classPK, java.lang.String name, java.lang.String description,
1122                    java.lang.String type, java.lang.String mode,
1123                    java.lang.String language, boolean andOperator) {
1124                    return _ddmTemplateLocalService.searchCount(companyId, groupId,
1125                            classNameId, classPK, name, description, type, mode, language,
1126                            andOperator);
1127            }
1128    
1129            /**
1130            * Returns the number of templates matching the group IDs, class name IDs,
1131            * class PK, type, and mode, and matching the keywords in the template names
1132            * and descriptions.
1133            *
1134            * @param companyId the primary key of the template's company
1135            * @param groupIds the primary keys of the groups
1136            * @param classNameIds the primary keys of the entity's instance the
1137            templates are related to
1138            * @param classPKs the primary keys of the template's related entities
1139            * @param keywords the keywords (space separated), which may occur in the
1140            template's name or description (optionally <code>null</code>)
1141            * @param type the template's type (optionally <code>null</code>). For more
1142            information, see {@link
1143            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1144            * @param mode the template's mode (optionally <code>null</code>). For more
1145            information, see {@link
1146            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1147            * @return the number of matching templates
1148            */
1149            @Override
1150            public int searchCount(long companyId, long[] groupIds,
1151                    long[] classNameIds, long[] classPKs, java.lang.String keywords,
1152                    java.lang.String type, java.lang.String mode) {
1153                    return _ddmTemplateLocalService.searchCount(companyId, groupIds,
1154                            classNameIds, classPKs, keywords, type, mode);
1155            }
1156    
1157            /**
1158            * Returns the number of templates matching the group IDs, class name IDs,
1159            * class PKs, name keyword, description keyword, type, mode, and language.
1160            *
1161            * @param companyId the primary key of the templates company
1162            * @param groupIds the primary keys of the groups
1163            * @param classNameIds the primary keys of the entity's instance the
1164            templates are related to
1165            * @param classPKs the primary keys of the template's related entities
1166            * @param name the name keywords (optionally <code>null</code>)
1167            * @param description the description keywords (optionally
1168            <code>null</code>)
1169            * @param type the template's type (optionally <code>null</code>). For more
1170            information, see {@link
1171            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1172            * @param mode the template's mode (optionally <code>null</code>). For more
1173            information, see {@link
1174            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1175            * @param language the template's script language (optionally
1176            <code>null</code>). For more information, see {@link
1177            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1178            * @param andOperator whether every field must match its keywords, or just
1179            one field.
1180            * @return the number of matching templates
1181            */
1182            @Override
1183            public int searchCount(long companyId, long[] groupIds,
1184                    long[] classNameIds, long[] classPKs, java.lang.String name,
1185                    java.lang.String description, java.lang.String type,
1186                    java.lang.String mode, java.lang.String language, boolean andOperator) {
1187                    return _ddmTemplateLocalService.searchCount(companyId, groupIds,
1188                            classNameIds, classPKs, name, description, type, mode, language,
1189                            andOperator);
1190            }
1191    
1192            /**
1193            * Sets the Spring bean ID for this bean.
1194            *
1195            * @param beanIdentifier the Spring bean ID for this bean
1196            */
1197            @Override
1198            public void setBeanIdentifier(java.lang.String beanIdentifier) {
1199                    _ddmTemplateLocalService.setBeanIdentifier(beanIdentifier);
1200            }
1201    
1202            /**
1203            * Updates the d d m template in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
1204            *
1205            * @param ddmTemplate the d d m template
1206            * @return the d d m template that was updated
1207            */
1208            @Override
1209            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate updateDDMTemplate(
1210                    com.liferay.portlet.dynamicdatamapping.model.DDMTemplate ddmTemplate) {
1211                    return _ddmTemplateLocalService.updateDDMTemplate(ddmTemplate);
1212            }
1213    
1214            /**
1215            * Updates the template matching the ID.
1216            *
1217            * @param templateId the primary key of the template
1218            * @param classPK the primary key of the template's related entity
1219            * @param nameMap the template's new locales and localized names
1220            * @param descriptionMap the template's new locales and localized
1221            description
1222            * @param type the template's type. For more information, see {@link
1223            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1224            * @param mode the template's mode. For more information, see {@link
1225            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1226            * @param language the template's script language. For more information,
1227            see {@link
1228            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1229            * @param script the template's script
1230            * @param cacheable whether the template is cacheable
1231            * @param serviceContext the service context to be applied. Can set the
1232            modification date.
1233            * @return the updated template
1234            * @throws PortalException if a portal exception occurred
1235            */
1236            @Override
1237            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate updateTemplate(
1238                    long templateId, long classPK,
1239                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1240                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1241                    java.lang.String type, java.lang.String mode,
1242                    java.lang.String language, java.lang.String script, boolean cacheable,
1243                    com.liferay.portal.service.ServiceContext serviceContext)
1244                    throws com.liferay.portal.kernel.exception.PortalException {
1245                    return _ddmTemplateLocalService.updateTemplate(templateId, classPK,
1246                            nameMap, descriptionMap, type, mode, language, script, cacheable,
1247                            serviceContext);
1248            }
1249    
1250            /**
1251            * Updates the template matching the ID.
1252            *
1253            * @param templateId the primary key of the template
1254            * @param classPK the primary key of the template's related entity
1255            * @param nameMap the template's new locales and localized names
1256            * @param descriptionMap the template's new locales and localized
1257            description
1258            * @param type the template's type. For more information, see {@link
1259            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1260            * @param mode the template's mode. For more information, see {@link
1261            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1262            * @param language the template's script language. For more information,
1263            see {@link
1264            com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants}.
1265            * @param script the template's script
1266            * @param cacheable whether the template is cacheable
1267            * @param smallImage whether the template has a small image
1268            * @param smallImageURL the template's small image URL (optionally
1269            <code>null</code>)
1270            * @param smallImageFile the template's small image file (optionally
1271            <code>null</code>)
1272            * @param serviceContext the service context to be applied. Can set the
1273            modification date.
1274            * @return the updated template
1275            * @throws PortalException if a portal exception occurred
1276            */
1277            @Override
1278            public com.liferay.portlet.dynamicdatamapping.model.DDMTemplate updateTemplate(
1279                    long templateId, long classPK,
1280                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1281                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1282                    java.lang.String type, java.lang.String mode,
1283                    java.lang.String language, java.lang.String script, boolean cacheable,
1284                    boolean smallImage, java.lang.String smallImageURL,
1285                    java.io.File smallImageFile,
1286                    com.liferay.portal.service.ServiceContext serviceContext)
1287                    throws com.liferay.portal.kernel.exception.PortalException {
1288                    return _ddmTemplateLocalService.updateTemplate(templateId, classPK,
1289                            nameMap, descriptionMap, type, mode, language, script, cacheable,
1290                            smallImage, smallImageURL, smallImageFile, serviceContext);
1291            }
1292    
1293            /**
1294             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
1295             */
1296            @Deprecated
1297            public DDMTemplateLocalService getWrappedDDMTemplateLocalService() {
1298                    return _ddmTemplateLocalService;
1299            }
1300    
1301            /**
1302             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
1303             */
1304            @Deprecated
1305            public void setWrappedDDMTemplateLocalService(
1306                    DDMTemplateLocalService ddmTemplateLocalService) {
1307                    _ddmTemplateLocalService = ddmTemplateLocalService;
1308            }
1309    
1310            @Override
1311            public DDMTemplateLocalService getWrappedService() {
1312                    return _ddmTemplateLocalService;
1313            }
1314    
1315            @Override
1316            public void setWrappedService(
1317                    DDMTemplateLocalService ddmTemplateLocalService) {
1318                    _ddmTemplateLocalService = ddmTemplateLocalService;
1319            }
1320    
1321            private DDMTemplateLocalService _ddmTemplateLocalService;
1322    }