// Elementor Template Service - Manage Elementor templates
import { AxiosInstance } from 'axios';
import { logger } from '../../utils/logger.js';
import { ErrorHandler } from '../../utils/error-handler.js';
import { ElementorTemplate } from '../../types/elementor.js';
export class ElementorTemplateService {
constructor(private client: AxiosInstance) {}
/**
* Get Elementor templates
*/
async getTemplates(
perPage: number = 10,
type?: 'page' | 'section' | 'widget'
): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
logger.debug('Fetching Elementor templates', { perPage, type });
const params: any = {
per_page: perPage,
post_type: 'elementor_library'
};
if (type) {
params.meta_key = '_elementor_template_type';
params.meta_value = type;
}
const response = await this.client.get('/posts', { params });
return {
templates: response.data,
total: response.headers['x-wp-total'],
totalPages: response.headers['x-wp-totalpages']
};
}, 'ElementorTemplateService.getTemplates');
}
/**
* Get a specific template
*/
async getTemplate(templateId: number): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
logger.debug(`Fetching template ${templateId}`);
const response = await this.client.get(`/posts/${templateId}`, {
params: { context: 'edit' }
});
return {
id: response.data.id,
title: response.data.title.rendered,
type: response.data.meta._elementor_template_type,
content: response.data.meta._elementor_data,
settings: response.data.meta._elementor_page_settings || {}
};
}, 'ElementorTemplateService.getTemplate');
}
/**
* Create a new template
*/
async createTemplate(
title: string,
type: 'page' | 'section' | 'widget',
content: string,
settings?: Record<string, any>
): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
logger.info('Creating Elementor template', { title, type });
const response = await this.client.post('/posts', {
title,
status: 'publish',
type: 'elementor_library',
meta: {
_elementor_template_type: type,
_elementor_data: content,
_elementor_page_settings: JSON.stringify(settings || {}),
_elementor_edit_mode: 'builder'
}
});
logger.info('Template created', { id: response.data.id });
return response.data;
}, 'ElementorTemplateService.createTemplate');
}
/**
* Update a template
*/
async updateTemplate(
templateId: number,
updates: {
title?: string;
content?: string;
settings?: Record<string, any>;
}
): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
logger.info(`Updating template ${templateId}`);
const payload: any = {};
if (updates.title) payload.title = updates.title;
if (updates.content || updates.settings) {
payload.meta = {};
if (updates.content) payload.meta._elementor_data = updates.content;
if (updates.settings) {
payload.meta._elementor_page_settings = JSON.stringify(updates.settings);
}
}
const response = await this.client.post(`/posts/${templateId}`, payload);
logger.info('Template updated', { id: templateId });
return response.data;
}, 'ElementorTemplateService.updateTemplate');
}
/**
* Delete a template
*/
async deleteTemplate(templateId: number, force: boolean = false): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
logger.info(`Deleting template ${templateId}`);
const response = await this.client.delete(`/posts/${templateId}`, {
params: { force }
});
logger.info('Template deleted', { id: templateId });
return response.data;
}, 'ElementorTemplateService.deleteTemplate');
}
/**
* Apply template to a page
*/
async applyTemplateToPage(pageId: number, templateId: number): Promise<void> {
return ErrorHandler.wrapAsync(async () => {
logger.info(`Applying template ${templateId} to page ${pageId}`);
// Get template data
const template = await this.getTemplate(templateId);
// Apply to page
await this.client.post(`/pages/${pageId}`, {
meta: {
_elementor_data: template.content,
_elementor_page_settings: JSON.stringify(template.settings),
_elementor_edit_mode: 'builder'
}
});
logger.info('Template applied successfully');
}, 'ElementorTemplateService.applyTemplateToPage');
}
}