#![cfg(feature = "mysql")]
use crate::action::sql_bridge::count_with_tree;
use crate::action::{ActionContext, TypedHandler};
use crate::error::BaseError;
use crate::table::{AsColumnName, Filter, SortOrder, TableEntity, WhereCondition};
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use std::marker::PhantomData;
use yang_base_derive::Action;
fn default_page() -> u32 {
1
}
fn default_page_size() -> u32 {
10
}
fn default_sort_order() -> SortOrder {
SortOrder::Asc
}
#[derive(schemars::JsonSchema)]
pub struct OrderByItem<T: TableEntity> {
pub field: T::Field,
pub direction: SortOrder,
}
impl<'de, T: TableEntity> Deserialize<'de> for OrderByItem<T> {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
#[derive(Deserialize)]
struct Raw<F> {
field: F,
#[serde(default = "default_sort_order")]
direction: SortOrder,
}
let raw = Raw::<T::Field>::deserialize(d)?;
Ok(OrderByItem {
field: raw.field,
direction: raw.direction,
})
}
}
#[derive(schemars::JsonSchema)]
pub struct SelectQuery<T: TableEntity> {
pub page: u32,
pub page_size: u32,
pub where_clause: Option<Filter<T::WhereCond>>,
pub order_by: Vec<OrderByItem<T>>,
pub count_total: bool,
}
impl<'de, T: TableEntity> Deserialize<'de> for SelectQuery<T> {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Raw<W, OI> {
#[serde(default = "default_page")]
page: u32,
#[serde(default = "default_page_size")]
page_size: u32,
#[serde(rename = "where", default = "Option::default")]
where_clause: Option<W>,
#[serde(default = "Vec::new")]
order_by: Vec<OI>,
#[serde(default)]
count_total: bool,
}
let raw = Raw::<Filter<T::WhereCond>, OrderByItem<T>>::deserialize(d)?;
Ok(SelectQuery {
page: raw.page,
page_size: raw.page_size,
where_clause: raw.where_clause,
order_by: raw.order_by,
count_total: raw.count_total,
})
}
}
#[derive(Serialize, schemars::JsonSchema)]
pub struct SelectResult<T> {
pub items: Vec<T>,
pub page: u32,
pub page_size: u32,
#[serde(skip_serializing_if = "Option::is_none")]
pub total: Option<u64>,
}
#[derive(Action)]
#[action(
name = "select",
display_name = "查询列表",
description = "分页 + 多条件 AND 查询"
)]
pub struct SelectAction<T: TableEntity> {
_phantom: PhantomData<T>,
}
impl<T: TableEntity> SelectAction<T> {
pub fn new() -> Self {
Self {
_phantom: PhantomData,
}
}
}
impl<T: TableEntity> Default for SelectAction<T> {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl<T: TableEntity> TypedHandler for SelectAction<T> {
type Input = SelectQuery<T>;
type Output = SelectResult<T>;
async fn handle(
&self,
ctx: ActionContext,
input: SelectQuery<T>,
) -> Result<SelectResult<T>, BaseError> {
if input.page == 0 || input.page_size == 0 || input.page_size > 100 {
return Err(BaseError::ParamInvalid(
"page/page_size".into(),
"page>=1, 1<=page_size<=100".into(),
));
}
let where_tree: Option<WhereCondition> =
input.where_clause.map(Filter::into_where_condition);
let user = ctx
.user
.as_ref()
.ok_or_else(|| BaseError::Unauthorized("需要登录".to_string()))?;
let mut q = ctx.table_query()?;
q.ensure_fields_readable(user)?;
let total = if input.count_total {
match &where_tree {
Some(tree) => Some(count_with_tree(&ctx, tree.clone()).await?),
None => Some(ctx.table_query()?.count().await?),
}
} else {
None
};
if let Some(tree) = where_tree {
q = q.where_tree(tree)?;
}
for OrderByItem { field, direction } in input.order_by {
q = q.order_by(field.column_name(), direction)?;
}
q = q.page(input.page as usize, input.page_size as usize)?;
let items: Vec<T> = q.select::<T>().await?;
Ok(SelectResult {
items,
page: input.page,
page_size: input.page_size,
total,
})
}
}