/*
* 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.385.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(),
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. 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`. - `seo.title` / `seo.description` map to Shopify's global `title_tag` and `description_tag` metafields (the fields Shopify themes read for the page title and meta description), and on Wix to the post's SEO title and meta description. WordPress and Webflow reject `seo`; SEO plugin and custom-field writes are not supported. - 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 to its rich text field, `excerpt` to a summary field, `image` to an image field, `tags` and `author` 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 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. Supported on Shopify (`shopify`), WordPress (`wordpress`), Wix (`wix`) and Webflow (`webflow`). WordPress native scheduling depends on the site's scheduler/WP-Cron.
pub async fn create_blog_article(
configuration: &configuration::Configuration,
account_id: &str,
blog_id: &str,
create_blog_article_request: models::CreateBlogArticleRequest,
) -> 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 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(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. On WordPress the post is force-deleted, while uploaded attachments and tags remain in the site's media library and taxonomy. On Webflow the item is unpublished from the live site, then deleted from the collection. Supported on Shopify (`shopify`), WordPress (`wordpress`), Wix (`wix`) and Webflow (`webflow`).
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. 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. Supported on Shopify (`shopify`), WordPress (`wordpress`), Wix (`wix`) and Webflow (`webflow`). 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. Shopify returns its store blogs with cursor pagination. A WordPress or Wix account represents one site and always returns exactly that one blog with `nextCursor: null`. A Webflow site returns each CMS collection that has a rich text field (its blog id is the collection id), with `nextCursor: null`. `limit` is 1-50 (default 20). Treat `nextCursor` as opaque; pass it unchanged on the next request. Supported on Shopify (`shopify`), WordPress (`wordpress`), Wix (`wix`) and Webflow (`webflow`).
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. 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). `isPublished` and `publishDate` behave as on create: `isPublished: false` unpublishes back to a draft and 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. WordPress rejects `seo` and does not support SEO-plugin/custom-field, category, or custom-post-type writes. On Webflow, an edit to a published item goes live immediately, `isPublished: false` unpublishes it, and a future `publishDate` returns 400. Supported on Shopify (`shopify`), WordPress (`wordpress`), Wix (`wix`) and Webflow (`webflow`).
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,
}))
}
}