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,
};
ImportRunner::new().sheets(sheets)
}
pub fn export_runner(&self) -> ExportRunner {
ExportRunner::new(
SheetOptions::new(self.default_sheet()).columns(self.columns.clone()),
)
}
pub fn export_runner_for(&self, sheet_name: impl Into<String>) -> ExportRunner {
ExportRunner::new(
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)| (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| SheetOptions::new(name).columns(self.columns.clone()))
.collect();
self.export_runner().export_multi_sheet(path, options, fetch).await
}
}
impl<T: ExcelRow + Serialize> crate::executor::ErasedExecutor for Executor<T> {
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)
}
}
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 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>;
}