use std::future::Future;
use std::path::Path;
use std::time::Instant;
use tokio::sync::mpsc;
use crate::column::ColumnDef;
use crate::error::{ExcelError, Result};
use crate::export::{ExportStats, Page};
use crate::header::{normalize_header, simple_columns};
use crate::model::DynamicRow;
use crate::value::CellValue;
use crate::write::{ExcelWriter, SheetOptions, WriteOptions};
pub fn align_row(headers: &[String], values: &[(String, CellValue)]) -> Vec<CellValue> {
headers
.iter()
.map(|h| {
if let Some((_, v)) = values.iter().find(|(k, _)| k == h) {
return v.clone();
}
let nh = normalize_header(h);
values
.iter()
.find(|(k, _)| normalize_header(k) == nh)
.map(|(_, v)| v.clone())
.unwrap_or(CellValue::Empty)
})
.collect()
}
#[derive(Debug, Clone)]
pub struct DynamicSheet {
pub sheet: SheetOptions,
}
impl DynamicSheet {
pub fn new(name: impl Into<String>) -> Self {
Self {
sheet: SheetOptions::new(name),
}
}
pub fn headers<I, S>(self, headers: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.columns(simple_columns(headers))
}
pub fn columns<I>(mut self, columns: I) -> Self
where
I: IntoIterator<Item = ColumnDef>,
{
self.sheet = self.sheet.columns(columns);
self
}
pub fn write_options(mut self, write: WriteOptions) -> Self {
self.sheet = self.sheet.write_options(write);
self
}
pub fn headers_vec(&self) -> Vec<String> {
self.sheet.columns.iter().map(|c| c.header.clone()).collect()
}
}
pub fn named_xlsx_bytes(sheet: &DynamicSheet, rows: &[DynamicRow]) -> Result<Vec<u8>> {
let mut writer = ExcelWriter::new();
{
let mut ws = writer.add_sheet(&sheet.sheet)?;
ws.write_headers()?;
let headers = sheet.headers_vec();
for row in rows {
ws.write_row(&align_row(&headers, &row.entries))?;
}
ws.finish()?;
}
writer.save_to_buffer()
}
pub fn write_named_xlsx<P: AsRef<Path>>(
path: P,
sheet: &DynamicSheet,
rows: &[DynamicRow],
) -> Result<u64> {
let mut writer = ExcelWriter::new();
{
let mut ws = writer.add_sheet(&sheet.sheet)?;
ws.write_headers()?;
let headers = sheet.headers_vec();
for row in rows {
ws.write_row(&align_row(&headers, &row.entries))?;
}
ws.finish()?;
}
writer.save(path)
}
pub fn positional_xlsx_bytes(sheet: &DynamicSheet, rows: &[Vec<CellValue>]) -> Result<Vec<u8>> {
let mut writer = ExcelWriter::new();
{
let mut ws = writer.add_sheet(&sheet.sheet)?;
ws.write_headers()?;
for row in rows {
ws.write_row(row)?;
}
ws.finish()?;
}
writer.save_to_buffer()
}
pub fn write_positional_xlsx<P: AsRef<Path>>(
path: P,
sheet: &DynamicSheet,
rows: &[Vec<CellValue>],
) -> Result<u64> {
let mut writer = ExcelWriter::new();
{
let mut ws = writer.add_sheet(&sheet.sheet)?;
ws.write_headers()?;
for row in rows {
ws.write_row(row)?;
}
ws.finish()?;
}
writer.save(path)
}
#[derive(Debug, Clone)]
pub struct DynamicExportRunner {
sheet: DynamicSheet,
queue_pages: usize,
}
impl DynamicExportRunner {
pub fn new(sheet: DynamicSheet) -> Self {
Self {
sheet,
queue_pages: 2,
}
}
pub fn queue_pages(mut self, pages: usize) -> Self {
self.queue_pages = pages.max(1);
self
}
pub async fn export_named<P, F, Fut>(&self, path: P, mut fetch: F) -> Result<ExportStats>
where
P: AsRef<Path>,
F: FnMut(Option<String>) -> Fut,
Fut: Future<Output = Result<Page<DynamicRow>>> + Send,
{
let started = Instant::now();
let out_path = path.as_ref().to_path_buf();
let headers = self.sheet.headers_vec();
let sheet = self.sheet.sheet.clone();
let write_path = out_path.clone();
let (tx, mut rx) = mpsc::channel::<Vec<Vec<CellValue>>>(self.queue_pages);
let writer_task = tokio::task::spawn_blocking(move || -> Result<u64> {
let mut writer = ExcelWriter::new();
let mut ws = writer.add_sheet(&sheet)?;
ws.write_headers()?;
while let Some(rows) = rx.blocking_recv() {
for cells in &rows {
ws.write_row(cells)?;
}
}
ws.finish()?;
drop(ws);
writer.save(&write_path)
});
let mut cursor: Option<String> = None;
let mut pages = 0u64;
let mut rows_total = 0u64;
let fetch_result: Result<()> = async {
loop {
let page = fetch(cursor.clone()).await?;
pages += 1;
let done = page.done;
let next = page.cursor.clone();
rows_total += page.rows.len() as u64;
if !page.rows.is_empty() {
let aligned: Vec<Vec<CellValue>> = page
.rows
.iter()
.map(|r| align_row(&headers, &r.entries))
.collect();
tx.send(aligned)
.await
.map_err(|_| ExcelError::Other("导出写出任务已结束".to_string()))?;
}
if done {
break;
}
if next.is_none() {
log::warn!("动态导出分页既没有 done 也没有 cursor,提前结束");
break;
}
cursor = next;
}
Ok(())
}
.await;
drop(tx);
let file_size = writer_task
.await
.map_err(|e| ExcelError::Other(format!("导出写出线程异常:{e}")))??;
if let Err(e) = fetch_result {
let _ = std::fs::remove_file(&out_path);
return Err(e);
}
Ok(ExportStats {
rows: rows_total,
pages,
file_size,
elapsed_ms: started.elapsed().as_millis() as u64,
path: out_path.to_string_lossy().into_owned(),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_align_row() {
let headers = vec!["品名".to_string(), "数量".to_string(), "备注".to_string()];
let values = vec![
("数量".to_string(), CellValue::Number(3.0)),
(" 品 名 ".to_string(), CellValue::Text("甲".into())),
("其他".to_string(), CellValue::Text("忽略".into())),
];
let row = align_row(&headers, &values);
assert_eq!(row.len(), 3);
assert_eq!(row[0].to_text(), "甲");
assert_eq!(row[1].to_text(), "3");
assert!(row[2].is_empty());
}
}