use std::any::type_name;
use std::fmt;
use std::future::Future;
use std::marker::PhantomData;
use std::path::Path;
use std::sync::Arc;
use serde::Serialize;
use crate::column::ColumnDef;
use crate::error::{ExcelError, Result};
use crate::export::{ExportRunner, ExportStats, Page};
use crate::import::{BatchSink, ImportPreview, ImportReport, ImportRunner};
use crate::model::{ExcelRow, RowData};
use crate::read::{SheetSelector, ZipSource};
use crate::write::{SheetOptions, TemplateSpec};
pub trait ExcelExecutor: ExcelRow {
const EXECUTOR_NAME: &'static str;
}
pub fn executor_for<T: ExcelExecutor>() -> Executor<T> {
Executor::new(T::EXECUTOR_NAME, T::sheet_name())
}
#[derive(Clone)]
pub struct Executor<T> {
name: &'static str,
sheet: Option<&'static str>,
columns: Vec<ColumnDef>,
_marker: PhantomData<fn() -> T>,
}
impl<T: ExcelRow> Executor<T> {
pub fn new(name: &'static str, sheet: Option<&'static str>) -> Self {
Self {
name,
sheet,
columns: T::columns(),
_marker: PhantomData,
}
}
pub fn name(&self) -> &'static str {
self.name
}
pub fn type_name(&self) -> &'static str {
type_name::<T>()
}
pub fn sheet_name(&self) -> Option<&'static str> {
self.sheet
}
pub fn columns(&self) -> &[ColumnDef] {
&self.columns
}
fn default_sheet(&self) -> String {
self.sheet.unwrap_or("Sheet1").to_string()
}
pub fn import_runner(&self) -> ImportRunner {
let sheets = match self.sheet {
Some(name) => SheetSelector::Name(name.to_string()),
None => SheetSelector::All,
};
apply_import_config(self.name, ImportRunner::new().sheets(sheets))
}
pub fn export_runner(&self) -> ExportRunner {
ExportRunner::new(apply_export_config(
self.name,
SheetOptions::new(self.default_sheet()).columns(self.columns.clone()),
))
}
pub fn export_runner_for(&self, sheet_name: impl Into<String>) -> ExportRunner {
ExportRunner::new(apply_export_config(
self.name,
SheetOptions::new(sheet_name).columns(self.columns.clone()),
))
}
pub fn template(&self) -> TemplateSpec {
TemplateSpec::new(self.columns.clone()).sheet_name(self.default_sheet())
}
}
impl<T: ExcelRow> Executor<T> {
pub fn preview(
&self,
source: ZipSource,
limit: usize,
) -> Result<ImportPreview<T>>
where
T: Serialize,
{
self.import_runner().preview::<T>(source, limit)
}
pub fn preview_json(
&self,
source: ZipSource,
limit: usize,
) -> Result<serde_json::Value>
where
T: Serialize,
{
let preview = self.preview(source, limit)?;
serde_json::to_value(&preview).map_err(ExcelError::from)
}
pub async fn commit<S>(&self, source: ZipSource, sink: Arc<S>) -> Result<ImportReport>
where
S: BatchSink<T> + ?Sized,
{
self.import_runner().commit::<T, S>(source, sink).await
}
pub fn for_each_row<F>(&self, source: ZipSource, on_row: F) -> Result<ImportReport>
where
F: FnMut(&RowData<'_>, T) -> std::result::Result<(), Vec<String>>,
{
self.import_runner()
.for_each_row::<T, F>(source, on_row)
}
pub fn export_bytes(&self, rows: &[T]) -> Result<Vec<u8>> {
self.export_runner().export_bytes(rows)
}
pub fn export_rows<P: AsRef<Path>>(&self, path: P, rows: &[T]) -> Result<u64> {
self.export_runner().export_rows(path, rows)
}
pub fn export_sheets<P: AsRef<Path>>(
&self,
path: P,
named_rows: Vec<(String, Vec<T>)>,
) -> Result<ExportStats> {
let sheets = named_rows
.into_iter()
.map(|(name, rows)| {
(
apply_export_config(
self.name,
SheetOptions::new(name).columns(self.columns.clone()),
),
rows,
)
})
.collect();
self.export_runner().export_sheets(path, sheets)
}
pub async fn export_xlsx<P, F, Fut>(&self, path: P, fetch: F) -> Result<ExportStats>
where
P: AsRef<Path>,
F: FnMut(Option<String>) -> Fut,
Fut: Future<Output = Result<Page<T>>> + Send,
{
self.export_runner().export_xlsx(path, fetch).await
}
pub async fn export_multi_sheet<P, F, Fut>(
&self,
path: P,
sheets: Vec<String>,
fetch: F,
) -> Result<ExportStats>
where
P: AsRef<Path>,
F: FnMut(usize, Option<String>) -> Fut,
Fut: Future<Output = Result<Page<T>>> + Send,
{
let options: Vec<SheetOptions> = sheets
.into_iter()
.map(|name| {
apply_export_config(
self.name,
SheetOptions::new(name).columns(self.columns.clone()),
)
})
.collect();
self.export_runner().export_multi_sheet(path, options, fetch).await
}
}
#[async_trait::async_trait]
impl<T> ErasedExecutor for Executor<T>
where
T: ExcelRow + Serialize + serde::de::DeserializeOwned + Sync,
{
fn name(&self) -> &'static str {
self.name
}
fn type_name(&self) -> &'static str {
self.type_name()
}
fn preview(&self, source: ZipSource, limit: usize) -> Result<serde_json::Value> {
self.preview_json(source, limit)
}
async fn commit_json(
&self,
source: ZipSource,
sink: Arc<dyn JsonBatchSink>,
) -> Result<ImportReport> {
let bridge = Arc::new(JsonBridge::<T> {
inner: sink,
_marker: PhantomData,
});
self.import_runner().commit::<T, _>(source, bridge).await
}
fn export_bytes_json(&self, rows: &serde_json::Value) -> Result<Vec<u8>> {
let models: Vec<T> = serde_json::from_value(rows.clone())?;
self.export_runner().export_bytes(&models)
}
fn template(&self) -> TemplateSpec {
Executor::template(self)
}
}
impl<T> fmt::Debug for Executor<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Executor")
.field("name", &self.name)
.field("sheet", &self.sheet)
.field("model", &type_name::<T>())
.field("columns", &self.columns.len())
.finish()
}
}
#[derive(Debug)]
pub struct ExecutorEntry {
pub name: &'static str,
pub type_name: &'static str,
pub make: fn() -> Box<dyn ErasedExecutor>,
}
inventory::collect!(ExecutorEntry);
pub fn registered_executors() -> Vec<&'static ExecutorEntry> {
inventory::iter::<ExecutorEntry>
.into_iter()
.collect()
}
pub fn registered_names() -> Vec<&'static str> {
registered_executors()
.into_iter()
.map(|e| e.name)
.collect()
}
pub fn executor_entry(name: &str) -> Option<&'static ExecutorEntry> {
inventory::iter::<ExecutorEntry>
.into_iter()
.find(|e| e.name == name)
}
pub fn executor_by_name(name: &str) -> Option<Box<dyn ErasedExecutor>> {
executor_entry(name).map(|e| (e.make)())
}
pub fn preview_by_name(
name: &str,
source: ZipSource,
limit: usize,
) -> Result<Option<serde_json::Value>> {
match executor_by_name(name) {
Some(exec) => Ok(Some(exec.preview(source, limit)?)),
None => Ok(None),
}
}
pub async fn commit_json_by_name(
name: &str,
source: ZipSource,
sink: Arc<dyn JsonBatchSink>,
) -> Result<Option<ImportReport>> {
match executor_by_name(name) {
Some(exec) => Ok(Some(exec.commit_json(source, sink).await?)),
None => Ok(None),
}
}
pub fn export_bytes_by_name(name: &str, rows: &serde_json::Value) -> Result<Option<Vec<u8>>> {
match executor_by_name(name) {
Some(exec) => Ok(Some(exec.export_bytes_json(rows)?)),
None => Ok(None),
}
}
#[async_trait::async_trait]
pub trait JsonBatchSink: Send + Sync {
async fn save(&self, rows: Vec<serde_json::Value>)
-> std::result::Result<usize, ExcelError>;
}
#[async_trait::async_trait]
pub trait ErasedExecutor: Send + Sync {
fn name(&self) -> &'static str;
fn type_name(&self) -> &'static str;
fn preview(&self, source: ZipSource, limit: usize) -> Result<serde_json::Value>;
async fn commit_json(
&self,
source: ZipSource,
sink: Arc<dyn JsonBatchSink>,
) -> Result<ImportReport>;
fn export_bytes_json(&self, rows: &serde_json::Value) -> Result<Vec<u8>>;
fn template(&self) -> TemplateSpec;
}
struct JsonBridge<T> {
inner: Arc<dyn JsonBatchSink>,
_marker: PhantomData<fn() -> T>,
}
#[async_trait::async_trait]
impl<T> BatchSink<T> for JsonBridge<T>
where
T: Serialize + Send + Sync + 'static,
{
async fn save(&self, batch: Vec<T>) -> std::result::Result<usize, ExcelError> {
let rows: Vec<serde_json::Value> = batch
.iter()
.map(serde_json::to_value)
.collect::<std::result::Result<Vec<_>, _>>()?;
self.inner.save(rows).await
}
}
pub struct ExecutorConfigEntry {
pub name: &'static str,
pub import: fn(ImportRunner) -> ImportRunner,
pub export: fn(SheetOptions) -> SheetOptions,
}
inventory::collect!(ExecutorConfigEntry);
pub fn identity_import_runner(runner: ImportRunner) -> ImportRunner {
runner
}
pub fn identity_sheet_options(sheet: SheetOptions) -> SheetOptions {
sheet
}
pub fn executor_config_entry(name: &str) -> Option<&'static ExecutorConfigEntry> {
inventory::iter::<ExecutorConfigEntry>()
.find(|e| e.name == name)
}
fn apply_import_config(name: &str, runner: ImportRunner) -> ImportRunner {
match executor_config_entry(name) {
Some(e) => (e.import)(runner),
None => runner,
}
}
fn apply_export_config(name: &str, sheet: SheetOptions) -> SheetOptions {
match executor_config_entry(name) {
Some(e) => (e.export)(sheet),
None => sheet,
}
}