@ai-growth/n8n-nodes-wordpress
Version:
n8n node for WordPress integration with AI GROWTH - SEO WP plugin
678 lines (677 loc) • 37 kB
JavaScript
"use strict";
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __rest = (this && this.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
exports.__esModule = true;
exports.PostCreateService = void 0;
var ErrorUtils_1 = require("../utils/ErrorUtils");
var SeoService_1 = require("./SeoService");
var FaqService_1 = require("./FaqService");
var CtaService_1 = require("./CtaService");
var MetadataService_1 = require("./MetadataService");
var FeaturedImageService_1 = require("./FeaturedImageService");
/**
* Serviço para criação e atualização de posts e páginas no WordPress
*/
var PostCreateService = /** @class */ (function () {
/**
* Construtor do serviço
* @param client Cliente WordPress
*/
function PostCreateService(client) {
this.client = client;
this.seoService = new SeoService_1.SeoService(client);
this.faqService = new FaqService_1.FaqService(client, this.seoService);
this.ctaService = new CtaService_1.CtaService(client, this.seoService);
this.metadataService = new MetadataService_1.MetadataService(client);
this.featuredImageService = new FeaturedImageService_1.FeaturedImageService(client);
}
/**
* Cria um novo post no WordPress
* @param post Dados do post a ser criado
* @param options Opções da operação
* @returns Post criado
*/
PostCreateService.prototype.createPost = function (post, options) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var meta_title, meta_description, meta_keywords, faq, cta, postData, postPayload, response, postId, error_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 3, , 4]);
meta_title = post.meta_title, meta_description = post.meta_description, meta_keywords = post.meta_keywords, faq = post.faq, cta = post.cta, postData = __rest(post, ["meta_title", "meta_description", "meta_keywords", "faq", "cta"]);
postPayload = this.formatPostForApi(postData, 'post');
return [4 /*yield*/, this.client.post('wp/v2/posts', postPayload)];
case 1:
response = _a.sent();
if (!response || !response.id) {
throw new ErrorUtils_1.WordPressError('Failed to create WordPress post: Invalid response', ErrorUtils_1.WordPressErrorType.SERVER);
}
postId = response.id;
// Processar metadados SEO se necessário
return [4 /*yield*/, this.processMetadata(postId, post, options)];
case 2:
// Processar metadados SEO se necessário
_a.sent();
// Obter post completo com metadados
return [2 /*return*/, this.getCompletePost(postId, 'post', options)];
case 3:
error_1 = _a.sent();
if (error_1 instanceof ErrorUtils_1.WordPressError) {
throw error_1;
}
throw new ErrorUtils_1.WordPressError("Failed to create WordPress post: ".concat(error_1.message), ErrorUtils_1.WordPressErrorType.SERVER, undefined, error_1);
case 4: return [2 /*return*/];
}
});
});
};
/**
* Cria uma nova página no WordPress
* @param page Dados da página a ser criada
* @param options Opções da operação
* @returns Página criada
*/
PostCreateService.prototype.createPage = function (page, options) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var meta_title, meta_description, meta_keywords, faq, cta, pageData, pagePayload, response, pageId, error_2;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 3, , 4]);
meta_title = page.meta_title, meta_description = page.meta_description, meta_keywords = page.meta_keywords, faq = page.faq, cta = page.cta, pageData = __rest(page, ["meta_title", "meta_description", "meta_keywords", "faq", "cta"]);
pagePayload = this.formatPostForApi(pageData, 'page');
return [4 /*yield*/, this.client.post('wp/v2/pages', pagePayload)];
case 1:
response = _a.sent();
if (!response || !response.id) {
throw new ErrorUtils_1.WordPressError('Failed to create WordPress page: Invalid response', ErrorUtils_1.WordPressErrorType.SERVER);
}
pageId = response.id;
// Processar metadados SEO se necessário
return [4 /*yield*/, this.processMetadata(pageId, page, options)];
case 2:
// Processar metadados SEO se necessário
_a.sent();
// Obter página completa com metadados
return [2 /*return*/, this.getCompletePost(pageId, 'page', options)];
case 3:
error_2 = _a.sent();
if (error_2 instanceof ErrorUtils_1.WordPressError) {
throw error_2;
}
throw new ErrorUtils_1.WordPressError("Failed to create WordPress page: ".concat(error_2.message), ErrorUtils_1.WordPressErrorType.SERVER, undefined, error_2);
case 4: return [2 /*return*/];
}
});
});
};
/**
* Atualiza um post existente no WordPress
* @param postId ID do post a ser atualizado
* @param post Dados do post
* @param options Opções da operação
* @returns Post atualizado
*/
PostCreateService.prototype.updatePost = function (postId, post, options) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var meta_title, meta_description, meta_keywords, faq, cta, postData, postPayload, response, error_3;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 5, , 6]);
// Verificar se o post existe
return [4 /*yield*/, this.validateResourceExists(postId, 'post')];
case 1:
// Verificar se o post existe
_a.sent();
meta_title = post.meta_title, meta_description = post.meta_description, meta_keywords = post.meta_keywords, faq = post.faq, cta = post.cta, postData = __rest(post, ["meta_title", "meta_description", "meta_keywords", "faq", "cta"]);
postPayload = {};
// Adicionar campos apenas se definidos
if (postData.title !== undefined) {
postPayload.title = postData.title;
}
if (postData.content !== undefined) {
postPayload.content = postData.content;
}
if (postData.status !== undefined) {
postPayload.status = postData.status;
}
if (postData.excerpt !== undefined) {
postPayload.excerpt = postData.excerpt;
}
if (postData.slug !== undefined) {
postPayload.slug = postData.slug;
}
if (postData.featured_media !== undefined) {
postPayload.featured_media = postData.featured_media;
}
if (postData.categories !== undefined) {
postPayload.categories = postData.categories;
}
if (postData.tags !== undefined) {
postPayload.tags = postData.tags;
}
// Se não há campos para atualizar, verificar se há metadados para atualizar
if (Object.keys(postPayload).length === 0 &&
!meta_title && !meta_description && !meta_keywords && !faq && !cta) {
throw new ErrorUtils_1.WordPressError('No fields specified for update', ErrorUtils_1.WordPressErrorType.VALIDATION);
}
response = null;
if (!(Object.keys(postPayload).length > 0)) return [3 /*break*/, 3];
return [4 /*yield*/, this.client.put("wp/v2/posts/".concat(postId), postPayload)];
case 2:
response = _a.sent();
if (!response || !response.id) {
throw new ErrorUtils_1.WordPressError("Failed to update WordPress post with ID ".concat(postId, ": Invalid response"), ErrorUtils_1.WordPressErrorType.SERVER);
}
_a.label = 3;
case 3:
// Processar metadados SEO se necessário
return [4 /*yield*/, this.processMetadata(postId, __assign(__assign({}, post), { type: 'post' }), options)];
case 4:
// Processar metadados SEO se necessário
_a.sent();
// Obter post completo com metadados
return [2 /*return*/, this.getCompletePost(postId, 'post', options)];
case 5:
error_3 = _a.sent();
if (error_3 instanceof ErrorUtils_1.WordPressError) {
throw error_3;
}
throw new ErrorUtils_1.WordPressError("Failed to update WordPress post with ID ".concat(postId, ": ").concat(error_3.message), ErrorUtils_1.WordPressErrorType.SERVER, undefined, error_3);
case 6: return [2 /*return*/];
}
});
});
};
/**
* Atualiza uma página existente no WordPress
* @param pageId ID da página a ser atualizada
* @param page Dados da página
* @param options Opções da operação
* @returns Página atualizada
*/
PostCreateService.prototype.updatePage = function (pageId, page, options) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var meta_title, meta_description, meta_keywords, faq, cta, pageData, pagePayload, response, error_4;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 5, , 6]);
// Verificar se a página existe
return [4 /*yield*/, this.validateResourceExists(pageId, 'page')];
case 1:
// Verificar se a página existe
_a.sent();
meta_title = page.meta_title, meta_description = page.meta_description, meta_keywords = page.meta_keywords, faq = page.faq, cta = page.cta, pageData = __rest(page, ["meta_title", "meta_description", "meta_keywords", "faq", "cta"]);
pagePayload = {};
// Adicionar campos apenas se definidos
if (pageData.title !== undefined) {
pagePayload.title = pageData.title;
}
if (pageData.content !== undefined) {
pagePayload.content = pageData.content;
}
if (pageData.status !== undefined) {
pagePayload.status = pageData.status;
}
if (pageData.excerpt !== undefined) {
pagePayload.excerpt = pageData.excerpt;
}
if (pageData.slug !== undefined) {
pagePayload.slug = pageData.slug;
}
if (pageData.featured_media !== undefined) {
pagePayload.featured_media = pageData.featured_media;
}
// Se não há campos para atualizar, verificar se há metadados para atualizar
if (Object.keys(pagePayload).length === 0 &&
!meta_title && !meta_description && !meta_keywords && !faq && !cta) {
throw new ErrorUtils_1.WordPressError('No fields specified for update', ErrorUtils_1.WordPressErrorType.VALIDATION);
}
response = null;
if (!(Object.keys(pagePayload).length > 0)) return [3 /*break*/, 3];
return [4 /*yield*/, this.client.put("wp/v2/pages/".concat(pageId), pagePayload)];
case 2:
response = _a.sent();
if (!response || !response.id) {
throw new ErrorUtils_1.WordPressError("Failed to update WordPress page with ID ".concat(pageId, ": Invalid response"), ErrorUtils_1.WordPressErrorType.SERVER);
}
_a.label = 3;
case 3:
// Processar metadados SEO se necessário
return [4 /*yield*/, this.processMetadata(pageId, __assign(__assign({}, page), { type: 'page' }), options)];
case 4:
// Processar metadados SEO se necessário
_a.sent();
// Obter página completa com metadados
return [2 /*return*/, this.getCompletePost(pageId, 'page', options)];
case 5:
error_4 = _a.sent();
if (error_4 instanceof ErrorUtils_1.WordPressError) {
throw error_4;
}
throw new ErrorUtils_1.WordPressError("Failed to update WordPress page with ID ".concat(pageId, ": ").concat(error_4.message), ErrorUtils_1.WordPressErrorType.SERVER, undefined, error_4);
case 6: return [2 /*return*/];
}
});
});
};
/**
* Exclui um post do WordPress
* @param postId ID do post a ser excluído
* @param force Forçar exclusão permanente (true) ou mover para lixeira (false)
* @returns true se excluído com sucesso
*/
PostCreateService.prototype.deletePost = function (postId, force) {
if (force === void 0) { force = false; }
return __awaiter(this, void 0, void 0, function () {
var params, error_5;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 3, , 4]);
params = {};
// Adicionar parâmetro force se solicitado
if (force) {
params.force = 'true';
}
// Excluir post
return [4 /*yield*/, this.client.get("wp/v2/posts/".concat(postId), params)];
case 1:
// Excluir post
_a.sent();
return [4 /*yield*/, this.client["delete"]("wp/v2/posts/".concat(postId))];
case 2:
_a.sent();
return [2 /*return*/, true];
case 3:
error_5 = _a.sent();
if (error_5 instanceof ErrorUtils_1.WordPressError) {
throw error_5;
}
throw new ErrorUtils_1.WordPressError("Failed to delete WordPress post with ID ".concat(postId, ": ").concat(error_5.message), ErrorUtils_1.WordPressErrorType.SERVER, undefined, error_5);
case 4: return [2 /*return*/];
}
});
});
};
/**
* Exclui uma página do WordPress
* @param pageId ID da página a ser excluída
* @param force Forçar exclusão permanente (true) ou mover para lixeira (false)
* @returns true se excluída com sucesso
*/
PostCreateService.prototype.deletePage = function (pageId, force) {
if (force === void 0) { force = false; }
return __awaiter(this, void 0, void 0, function () {
var params, error_6;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 3, , 4]);
params = {};
// Adicionar parâmetro force se solicitado
if (force) {
params.force = 'true';
}
// Excluir página
return [4 /*yield*/, this.client.get("wp/v2/pages/".concat(pageId), params)];
case 1:
// Excluir página
_a.sent();
return [4 /*yield*/, this.client["delete"]("wp/v2/pages/".concat(pageId))];
case 2:
_a.sent();
return [2 /*return*/, true];
case 3:
error_6 = _a.sent();
if (error_6 instanceof ErrorUtils_1.WordPressError) {
throw error_6;
}
throw new ErrorUtils_1.WordPressError("Failed to delete WordPress page with ID ".concat(pageId, ": ").concat(error_6.message), ErrorUtils_1.WordPressErrorType.SERVER, undefined, error_6);
case 4: return [2 /*return*/];
}
});
});
};
/**
* Processa os metadados SEO, FAQ e CTA
* @param postId ID do post/página
* @param post Dados do post/página
* @param options Opções da operação
* @returns void
*/
PostCreateService.prototype.processMetadata = function (postId, post, options) {
return __awaiter(this, void 0, void 0, function () {
var _a, updateSeoMetadata, _b, updateFaqs, _c, updateCta, _d, updateFeaturedImage, pluginInfo, seoMetadata, error_7;
return __generator(this, function (_e) {
switch (_e.label) {
case 0:
_e.trys.push([0, 10, , 11]);
_a = options.updateSeoMetadata, updateSeoMetadata = _a === void 0 ? false : _a, _b = options.updateFaqs, updateFaqs = _b === void 0 ? false : _b, _c = options.updateCta, updateCta = _c === void 0 ? false : _c, _d = options.updateFeaturedImage, updateFeaturedImage = _d === void 0 ? false : _d;
return [4 /*yield*/, this.seoService.checkPluginAvailability()];
case 1:
pluginInfo = _e.sent();
// Se o plugin não está disponível, retornar sem fazer nada
if (pluginInfo.status !== 'active') {
return [2 /*return*/];
}
if (!(updateSeoMetadata && (post.meta_title !== undefined || post.meta_description !== undefined || post.meta_keywords !== undefined))) return [3 /*break*/, 3];
seoMetadata = {};
if (post.meta_title !== undefined) {
seoMetadata.meta_title = post.meta_title;
}
if (post.meta_description !== undefined) {
seoMetadata.meta_description = post.meta_description;
}
if (post.meta_keywords !== undefined) {
seoMetadata.meta_keywords = post.meta_keywords;
}
if (!(Object.keys(seoMetadata).length > 0)) return [3 /*break*/, 3];
return [4 /*yield*/, this.metadataService.updateMetadata(postId, seoMetadata)];
case 2:
_e.sent();
_e.label = 3;
case 3:
if (!(updateFaqs && post.faq !== undefined)) return [3 /*break*/, 5];
return [4 /*yield*/, this.faqService.updatePostFaqs(postId, post.faq)];
case 4:
_e.sent();
_e.label = 5;
case 5:
if (!(updateCta && post.cta !== undefined)) return [3 /*break*/, 7];
return [4 /*yield*/, this.ctaService.updatePostCta(postId, post.cta)];
case 6:
_e.sent();
_e.label = 7;
case 7:
if (!updateFeaturedImage) return [3 /*break*/, 9];
return [4 /*yield*/, this.processFeaturedImage(postId, post)];
case 8:
_e.sent();
_e.label = 9;
case 9: return [3 /*break*/, 11];
case 10:
error_7 = _e.sent();
throw new ErrorUtils_1.WordPressError("Failed to process metadata for post/page with ID ".concat(postId, ": ").concat(error_7.message), ErrorUtils_1.WordPressErrorType.SERVER, undefined, error_7);
case 11: return [2 /*return*/];
}
});
});
};
/**
* Processa a imagem destacada de um post/página
* @param postId ID do post/página
* @param post Dados do post/página
* @returns void
*/
PostCreateService.prototype.processFeaturedImage = function (postId, post) {
return __awaiter(this, void 0, void 0, function () {
var contentType, metadata, error_8;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 9, , 10]);
contentType = post.type === 'page' ? 'page' : 'post';
if (!post.featured_image_url) return [3 /*break*/, 2];
metadata = {
alt_text: post.featured_image_alt,
title: post.featured_image_title,
caption: post.featured_image_caption,
description: post.featured_image_description
};
// Fazer upload e definir a imagem destacada a partir da URL
return [4 /*yield*/, this.featuredImageService.setFeaturedImageFromUrl(postId, contentType, post.featured_image_url, { metadata: metadata })];
case 1:
// Fazer upload e definir a imagem destacada a partir da URL
_a.sent();
return [3 /*break*/, 8];
case 2:
if (!post.featured_image_id) return [3 /*break*/, 4];
// Definir imagem destacada a partir do ID existente
return [4 /*yield*/, this.featuredImageService.setFeaturedImage(postId, contentType, post.featured_image_id)];
case 3:
// Definir imagem destacada a partir do ID existente
_a.sent();
return [3 /*break*/, 8];
case 4:
if (!post.featured_media) return [3 /*break*/, 6];
// Definir imagem destacada a partir do ID de mídia
return [4 /*yield*/, this.featuredImageService.setFeaturedImage(postId, contentType, post.featured_media)];
case 5:
// Definir imagem destacada a partir do ID de mídia
_a.sent();
return [3 /*break*/, 8];
case 6:
if (!(post.featured_media === 0)) return [3 /*break*/, 8];
// Remover imagem destacada
return [4 /*yield*/, this.featuredImageService.removeFeaturedImage(postId, contentType)];
case 7:
// Remover imagem destacada
_a.sent();
_a.label = 8;
case 8: return [3 /*break*/, 10];
case 9:
error_8 = _a.sent();
// Logar erro mas não interromper a operação principal
console.error('Erro ao processar imagem destacada:', error_8);
return [3 /*break*/, 10];
case 10: return [2 /*return*/];
}
});
});
};
/**
* Formata um post/página para o formato esperado pela API WordPress
* @param post Dados do post
* @param type Tipo de conteúdo (post ou page)
* @returns Payload formatado para a API
*/
PostCreateService.prototype.formatPostForApi = function (post, type) {
// Converter para o formato esperado pela API WordPress
var payload = {
title: post.title,
content: post.content,
status: post.status || 'draft'
};
// Adicionar categorias se for um post
if (type === 'post' && post.categories && post.categories.length > 0) {
payload.categories = post.categories;
}
// Adicionar tags se for um post
if (type === 'post' && post.tags && post.tags.length > 0) {
payload.tags = post.tags;
}
return payload;
};
/**
* Obtém um post/página completo com metadados
* @param id ID do post/página
* @param type Tipo de conteúdo (post ou page)
* @param options Opções da operação
* @returns Post/página completo
*/
PostCreateService.prototype.getCompletePost = function (id, type, options) {
var _a, _b, _c;
return __awaiter(this, void 0, void 0, function () {
var _d, updateSeoMetadata, _e, updateFaqs, _f, updateCta, endpoint, response, formattedPost, pluginInfo, seoMetadata, error_9, faqs, error_10, cta, error_11;
return __generator(this, function (_g) {
switch (_g.label) {
case 0:
_d = options.updateSeoMetadata, updateSeoMetadata = _d === void 0 ? false : _d, _e = options.updateFaqs, updateFaqs = _e === void 0 ? false : _e, _f = options.updateCta, updateCta = _f === void 0 ? false : _f;
endpoint = type === 'post' ? "wp/v2/posts/".concat(id) : "wp/v2/pages/".concat(id);
return [4 /*yield*/, this.client.get(endpoint)];
case 1:
response = _g.sent();
formattedPost = {
id: response.id,
title: ((_a = response.title) === null || _a === void 0 ? void 0 : _a.rendered) || '',
content: ((_b = response.content) === null || _b === void 0 ? void 0 : _b.rendered) || '',
status: response.status || 'draft',
categories: type === 'post' ? response.categories || [] : [],
tags: type === 'post' ? response.tags || [] : [],
image_url: response.featured_media && typeof response.featured_media === 'number'
? '' // Não temos acesso direto à URL da imagem pelo ID
: ((_c = response.featured_media) === null || _c === void 0 ? void 0 : _c.source_url) || ''
};
return [4 /*yield*/, this.seoService.checkPluginAvailability()];
case 2:
pluginInfo = _g.sent();
// Se o plugin não está disponível, retorna o post sem metadados
if (pluginInfo.status !== 'active') {
return [2 /*return*/, formattedPost];
}
if (!updateSeoMetadata) return [3 /*break*/, 6];
_g.label = 3;
case 3:
_g.trys.push([3, 5, , 6]);
return [4 /*yield*/, this.seoService.getPostSeoMetadata(id)];
case 4:
seoMetadata = _g.sent();
if (seoMetadata) {
formattedPost.meta_title = seoMetadata.meta_title;
formattedPost.meta_description = seoMetadata.meta_description;
formattedPost.meta_keywords = seoMetadata.meta_keywords;
}
return [3 /*break*/, 6];
case 5:
error_9 = _g.sent();
return [3 /*break*/, 6];
case 6:
if (!updateFaqs) return [3 /*break*/, 10];
_g.label = 7;
case 7:
_g.trys.push([7, 9, , 10]);
return [4 /*yield*/, this.faqService.getPostFaqs(id)];
case 8:
faqs = _g.sent();
if (faqs && faqs.length > 0) {
formattedPost.faq = faqs;
}
return [3 /*break*/, 10];
case 9:
error_10 = _g.sent();
return [3 /*break*/, 10];
case 10:
if (!updateCta) return [3 /*break*/, 14];
_g.label = 11;
case 11:
_g.trys.push([11, 13, , 14]);
return [4 /*yield*/, this.ctaService.getPostCta(id)];
case 12:
cta = _g.sent();
if (cta) {
formattedPost.cta = cta;
}
return [3 /*break*/, 14];
case 13:
error_11 = _g.sent();
return [3 /*break*/, 14];
case 14: return [2 /*return*/, formattedPost];
}
});
});
};
/**
* Verifica se um post/página existe no WordPress
* @param id ID do post/página
* @param type Tipo de conteúdo (post ou page)
* @returns O post/página se existir
* @throws WordPressError se não existir
*/
PostCreateService.prototype.validateResourceExists = function (id, type) {
return __awaiter(this, void 0, void 0, function () {
var endpoint, response, error_12;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
endpoint = type === 'post' ? "wp/v2/posts/".concat(id) : "wp/v2/pages/".concat(id);
return [4 /*yield*/, this.client.get(endpoint)];
case 1:
response = _a.sent();
if (!response || !response.id) {
throw new ErrorUtils_1.WordPressError("".concat(type === 'post' ? 'Post' : 'Page', " with ID ").concat(id, " not found"), ErrorUtils_1.WordPressErrorType.NOT_FOUND);
}
return [2 /*return*/, response];
case 2:
error_12 = _a.sent();
// Se já é um WordPressError do tipo NOT_FOUND, apenas relançar
if (error_12 instanceof ErrorUtils_1.WordPressError && error_12.type === ErrorUtils_1.WordPressErrorType.NOT_FOUND) {
throw error_12;
}
// Se é um erro de outra natureza
if (error_12 instanceof ErrorUtils_1.WordPressError) {
throw error_12;
}
// Erro genérico
throw new ErrorUtils_1.WordPressError("Error validating ".concat(type, " with ID ").concat(id, ": ").concat(error_12.message), ErrorUtils_1.WordPressErrorType.UNKNOWN, undefined, error_12);
case 3: return [2 /*return*/];
}
});
});
};
return PostCreateService;
}());
exports.PostCreateService = PostCreateService;