/*
* Zernio API
*
* API reference for Zernio. Authenticate with a Bearer API key. Base URL: https://zernio.com/api Versioning and deprecation: all endpoints are versioned in the URL path (current version: /v1). Breaking changes only ship in a new path version; existing versions keep working. Deprecated operations are marked 'deprecated: true' in this spec and announced in the changelog (https://zernio.com/changelog) before removal. Errors: every 4xx/5xx response is application/json with a machine-readable 'code' and a human-readable 'error' message (see the ErrorResponse schema). Request ids: responses carry an X-Request-Id header with the id we log the request under. Quote it when reporting a problem. A valid x-request-id you send is reused as that id.
*
* The version of the OpenAPI document: 1.415.0
* Contact: support@zernio.com
* Generated by: https://openapi-generator.tech
*/
use super::{configuration, ContentType, Error};
use crate::{apis::ResponseContent, models};
use reqwest;
use serde::{de::Error as _, Deserialize, Serialize};
/// struct for typed errors of method [`create_blog`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateBlogError {
Status400(models::ErrorResponse),
Status401(models::ErrorResponse),
Status403(),
Status404(),
Status405(),
Status429(),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`create_blog_article`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateBlogArticleError {
Status400(models::ErrorResponse),
Status401(models::ErrorResponse),
Status403(),
Status404(),
Status405(),
Status409(),
Status422(),
Status429(),
Status502(),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`delete_blog`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteBlogError {
Status400(models::ErrorResponse),
Status401(models::ErrorResponse),
Status403(),
Status404(),
Status405(),
Status429(),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`delete_blog_article`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteBlogArticleError {
Status400(models::ErrorResponse),
Status401(models::ErrorResponse),
Status403(),
Status404(),
Status405(),
Status429(),
Status502(),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`get_blog`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetBlogError {
Status400(models::ErrorResponse),
Status401(models::ErrorResponse),
Status403(),
Status404(),
Status405(),
Status429(),
Status502(),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`get_blog_article`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetBlogArticleError {
Status400(models::ErrorResponse),
Status401(models::ErrorResponse),
Status403(),
Status404(),
Status405(),
Status429(),
Status502(),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`list_blog_articles`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListBlogArticlesError {
Status400(models::ErrorResponse),
Status401(models::ErrorResponse),
Status403(),
Status404(),
Status405(),
Status429(),
Status502(),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`list_blogs`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListBlogsError {
Status400(models::ErrorResponse),
Status401(models::ErrorResponse),
Status403(),
Status404(),
Status405(),
Status429(),
Status502(),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`update_blog`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateBlogError {
Status400(models::ErrorResponse),
Status401(models::ErrorResponse),
Status403(),
Status404(),
Status405(),
Status429(),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`update_blog_article`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateBlogArticleError {
Status400(models::ErrorResponse),
Status401(models::ErrorResponse),
Status403(),
Status404(),
Status405(),
Status429(),
Status502(),
UnknownValue(serde_json::Value),
}
/// Creates a blog on the connected store. The platform generates the URL `handle` from the title when omitted. Supported on Shopify (platform `shopify`). A WordPress or Wix connection is its existing site, so both return 405 for blog creation.
pub async fn create_blog(
configuration: &configuration::Configuration,
account_id: &str,
create_blog_request: models::CreateBlogRequest,
) -> Result<models::CreateBlog201Response, Error<CreateBlogError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_account_id = account_id;
let p_body_create_blog_request = create_blog_request;
let uri_str = format!(
"{}/v1/accounts/{accountId}/blogs",
configuration.base_path,
accountId = crate::apis::urlencode(p_path_account_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_create_blog_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateBlog201Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateBlog201Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<CreateBlogError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Creates an article on the blog. Supported on Shopify (`shopify`), WordPress (`wordpress`), Wix (`wix`) and Webflow (`webflow`). ### Publishing behavior - WordPress, Wix and Webflow default to a draft when both publishing fields are omitted. - `isPublished: false` keeps the article as a draft and takes priority over a future `publishDate`. - A future `publishDate` schedules publication natively on the platform. The platform publishes it at that time with no Zernio queue involved. - `isPublished: true` publishes immediately when there is no future `publishDate`. - WordPress native scheduling depends on the site's scheduler/WP-Cron. ### SEO `seo.title` / `seo.description` map to: - Shopify: the global `title_tag` and `description_tag` metafields (the fields Shopify themes read for the page title and meta description). - Wix: the post's SEO title and meta description. WordPress and Webflow reject `seo`; SEO plugin and custom-field writes are not supported. ### Webflow Webflow has no scheduling API: a future `publishDate` returns 400 unless `isPublished: false` keeps a draft. Fields map to the collection's own fields by type and slug: - The body goes to its rich text field. - `excerpt` goes to a summary field. - `image` goes to an image field. - `tags` and `author` go to tag and author reference fields. Sending a field the collection does not have returns 400, as does a collection that requires a field the Blogs API cannot fill. ### Wix Wix stores rich content. `bodyHtml` is converted on write (each top-level HTML element must fit 30,000 characters), and images in the body are imported into the site's Media Manager. ### Idempotency Send an Idempotency-Key header to make retries safe. A retry with the same key and body replays the original 201 instead of creating a second article. A retry while the first request is still running returns 409; retry after a short backoff.
pub async fn create_blog_article(
configuration: &configuration::Configuration,
account_id: &str,
blog_id: &str,
create_blog_article_request: models::CreateBlogArticleRequest,
idempotency_key: Option<&str>,
) -> Result<models::CreateBlogArticle201Response, Error<CreateBlogArticleError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_account_id = account_id;
let p_path_blog_id = blog_id;
let p_body_create_blog_article_request = create_blog_article_request;
let p_header_idempotency_key = idempotency_key;
let uri_str = format!(
"{}/v1/accounts/{accountId}/blogs/{blogId}/articles",
configuration.base_path,
accountId = crate::apis::urlencode(p_path_account_id),
blogId = crate::apis::urlencode(p_path_blog_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(param_value) = p_header_idempotency_key {
req_builder = req_builder.header("Idempotency-Key", param_value.to_string());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_create_blog_article_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateBlogArticle201Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateBlogArticle201Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<CreateBlogArticleError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Deletes the blog AND every article in it. The delete happens on the platform and is permanent; Zernio stores nothing to restore it from. Supported on Shopify (platform `shopify`). Disconnect a WordPress or Wix account instead of deleting its site; both return 405 here.
pub async fn delete_blog(
configuration: &configuration::Configuration,
account_id: &str,
blog_id: &str,
) -> Result<(), Error<DeleteBlogError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_account_id = account_id;
let p_path_blog_id = blog_id;
let uri_str = format!(
"{}/v1/accounts/{accountId}/blogs/{blogId}",
configuration.base_path,
accountId = crate::apis::urlencode(p_path_account_id),
blogId = crate::apis::urlencode(p_path_blog_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
if !status.is_client_error() && !status.is_server_error() {
Ok(())
} else {
let content = resp.text().await?;
let entity: Option<DeleteBlogError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Deletes the article. The delete happens on the platform and is permanent; Zernio stores nothing to restore it from. Supported on Shopify (`shopify`), WordPress (`wordpress`), Wix (`wix`) and Webflow (`webflow`). ### Platform behavior - WordPress: the post is force-deleted, while uploaded attachments and tags remain in the site's media library and taxonomy. - Webflow: the item is unpublished from the live site, then deleted from the collection.
pub async fn delete_blog_article(
configuration: &configuration::Configuration,
account_id: &str,
blog_id: &str,
article_id: &str,
) -> Result<(), Error<DeleteBlogArticleError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_account_id = account_id;
let p_path_blog_id = blog_id;
let p_path_article_id = article_id;
let uri_str = format!(
"{}/v1/accounts/{accountId}/blogs/{blogId}/articles/{articleId}",
configuration.base_path,
accountId = crate::apis::urlencode(p_path_account_id),
blogId = crate::apis::urlencode(p_path_blog_id),
articleId = crate::apis::urlencode(p_path_article_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
if !status.is_client_error() && !status.is_server_error() {
Ok(())
} else {
let content = resp.text().await?;
let entity: Option<DeleteBlogArticleError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Fetches a single blog. Use the platform-native `blogId` returned by `GET /v1/accounts/{accountId}/blogs`: a Shopify numeric blog id, the WordPress.com numeric site id, or `1` for a self-hosted WordPress or a Wix site. That `1` is scoped to its connected account.
pub async fn get_blog(
configuration: &configuration::Configuration,
account_id: &str,
blog_id: &str,
) -> Result<models::GetBlog200Response, Error<GetBlogError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_account_id = account_id;
let p_path_blog_id = blog_id;
let uri_str = format!(
"{}/v1/accounts/{accountId}/blogs/{blogId}",
configuration.base_path,
accountId = crate::apis::urlencode(p_path_account_id),
blogId = crate::apis::urlencode(p_path_blog_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetBlog200Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetBlog200Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<GetBlogError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Fetches a single article. An article addressed through a blog it does not belong to is a 404 (code blog_article_not_found). Supported on Shopify (`shopify`), WordPress (`wordpress`), Wix (`wix`) and Webflow (`webflow`). WordPress returns its native `status`; `publishedAt` is present only for a published post and `publishDate` only for a scheduled post.
pub async fn get_blog_article(
configuration: &configuration::Configuration,
account_id: &str,
blog_id: &str,
article_id: &str,
) -> Result<models::CreateBlogArticle201Response, Error<GetBlogArticleError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_account_id = account_id;
let p_path_blog_id = blog_id;
let p_path_article_id = article_id;
let uri_str = format!(
"{}/v1/accounts/{accountId}/blogs/{blogId}/articles/{articleId}",
configuration.base_path,
accountId = crate::apis::urlencode(p_path_account_id),
blogId = crate::apis::urlencode(p_path_blog_id),
articleId = crate::apis::urlencode(p_path_article_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateBlogArticle201Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateBlogArticle201Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<GetBlogArticleError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Lists the articles of a blog. Supported on Shopify (`shopify`), WordPress (`wordpress`), Wix (`wix`) and Webflow (`webflow`). ### Pagination Cursor-paginated: pass `limit` (1-50, default 20) and the `cursor` from a previous response's `nextCursor`. `nextCursor` is null when there are no more pages. Treat cursors as opaque and pass them unchanged. ### Platform differences - WordPress and Wix results include `status`, and include `publishDate` only for scheduled (`future`) posts. - Wix lists return `bodyHtml: null`; get the article for its body. - Webflow results report `status` as `publish` or `draft` only.
pub async fn list_blog_articles(
configuration: &configuration::Configuration,
account_id: &str,
blog_id: &str,
limit: Option<i32>,
cursor: Option<&str>,
) -> Result<models::ListBlogArticles200Response, Error<ListBlogArticlesError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_account_id = account_id;
let p_path_blog_id = blog_id;
let p_query_limit = limit;
let p_query_cursor = cursor;
let uri_str = format!(
"{}/v1/accounts/{accountId}/blogs/{blogId}/articles",
configuration.base_path,
accountId = crate::apis::urlencode(p_path_account_id),
blogId = crate::apis::urlencode(p_path_blog_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_query_limit {
req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_cursor {
req_builder = req_builder.query(&[("cursor", ¶m_value.to_string())]);
}
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListBlogArticles200Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListBlogArticles200Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<ListBlogArticlesError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Lists blogs on the connected account. Supported on Shopify (`shopify`), WordPress (`wordpress`), Wix (`wix`) and Webflow (`webflow`). ### By platform - Shopify: returns its store blogs with cursor pagination. - WordPress or Wix: the account represents one site and always returns exactly that one blog with `nextCursor: null`. - Webflow: returns each CMS collection that has a rich text field (its blog id is the collection id), with `nextCursor: null`. ### Pagination `limit` is 1-50 (default 20). Treat `nextCursor` as opaque; pass it unchanged on the next request.
pub async fn list_blogs(
configuration: &configuration::Configuration,
account_id: &str,
limit: Option<i32>,
cursor: Option<&str>,
) -> Result<models::ListBlogs200Response, Error<ListBlogsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_account_id = account_id;
let p_query_limit = limit;
let p_query_cursor = cursor;
let uri_str = format!(
"{}/v1/accounts/{accountId}/blogs",
configuration.base_path,
accountId = crate::apis::urlencode(p_path_account_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_query_limit {
req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_cursor {
req_builder = req_builder.query(&[("cursor", ¶m_value.to_string())]);
}
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListBlogs200Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListBlogs200Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<ListBlogsError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Partial-updates a blog. Send any subset of `title` and `handle`; at least one field is required (an empty body returns 400). Supported on Shopify (platform `shopify`). WordPress and Wix site settings are not writable through this API, so both return 405.
pub async fn update_blog(
configuration: &configuration::Configuration,
account_id: &str,
blog_id: &str,
update_blog_request: models::UpdateBlogRequest,
) -> Result<models::CreateBlog201Response, Error<UpdateBlogError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_account_id = account_id;
let p_path_blog_id = blog_id;
let p_body_update_blog_request = update_blog_request;
let uri_str = format!(
"{}/v1/accounts/{accountId}/blogs/{blogId}",
configuration.base_path,
accountId = crate::apis::urlencode(p_path_account_id),
blogId = crate::apis::urlencode(p_path_blog_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::PATCH, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_update_blog_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateBlog201Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateBlog201Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<UpdateBlogError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}
/// Partial-updates an article. Supported on Shopify (`shopify`), WordPress (`wordpress`), Wix (`wix`) and Webflow (`webflow`). Send any subset of the create fields: `title`, `bodyHtml`, `handle`, `tags`, `author`, `excerpt`, `image`, `seo`, `isPublished`, `publishDate`. At least one field is required (an empty body returns 400). ### Publishing `isPublished` and `publishDate` behave as on create: - `isPublished: false` unpublishes back to a draft. - A future `publishDate` schedules publication natively on the platform. - Omitting both fields preserves the current WordPress or Wix status. Omitting `image` preserves the current featured image; removal is not supported. ### Platform limits - **WordPress**: rejects `seo` and does not support SEO-plugin/custom-field, category, or custom-post-type writes. - **Webflow**: an edit to a published item goes live immediately, `isPublished: false` unpublishes it, and a future `publishDate` returns 400.
pub async fn update_blog_article(
configuration: &configuration::Configuration,
account_id: &str,
blog_id: &str,
article_id: &str,
update_blog_article_request: models::UpdateBlogArticleRequest,
) -> Result<models::CreateBlogArticle201Response, Error<UpdateBlogArticleError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_account_id = account_id;
let p_path_blog_id = blog_id;
let p_path_article_id = article_id;
let p_body_update_blog_article_request = update_blog_article_request;
let uri_str = format!(
"{}/v1/accounts/{accountId}/blogs/{blogId}/articles/{articleId}",
configuration.base_path,
accountId = crate::apis::urlencode(p_path_account_id),
blogId = crate::apis::urlencode(p_path_blog_id),
articleId = crate::apis::urlencode(p_path_article_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::PATCH, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_update_blog_article_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateBlogArticle201Response`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateBlogArticle201Response`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<UpdateBlogArticleError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent {
status,
content,
entity,
}))
}
}