cleaned up update.rs eco and corp

src/corporate/storage.rs

@@ -5,11 +5,9 @@ use crate::util::logger;
 
 use tokio::fs;
 use tokio::io::AsyncWriteExt;
-use chrono::{Datelike, NaiveDate};
 use std::collections::HashMap;
 use std::path::{PathBuf, Path};
 
-const BATCH_SIZE: usize = 500;
 
 /// Lightweight index entry - only metadata, no full event data
 #[derive(Debug, Clone)]
@@ -55,162 +53,6 @@ pub async fn build_event_index(paths: &DataPaths) -> anyhow::Result<Vec<EventInd
     Ok(index)
 }
 
-/// Load specific event by key (only loads its file)
-pub async fn lookup_event_by_key(
-    key: &str,
-    index: &[EventIndex]
-) -> anyhow::Result<Option<CompanyEvent>> {
-    let entry = index.iter().find(|e| e.key == key);
-    
-    if let Some(entry) = entry {
-        let content = fs::read_to_string(&entry.file_path).await?;
-        let events: Vec<CompanyEvent> = serde_json::from_str(&content)?;
-        Ok(events.into_iter().find(|e| event_key(e) == key))
-    } else {
-        Ok(None)
-    }
-}
-
-/// Stream events file by file with callback
-pub async fn stream_events_with_callback<F>(
-    paths: &DataPaths,
-    mut callback: F
-) -> anyhow::Result<usize>
-where
-    F: FnMut(CompanyEvent) -> anyhow::Result<()>,
-{
-    let dir = paths.corporate_events_dir();
-    if !dir.exists() {
-        return Ok(0);
-    }
-
-    let mut total = 0;
-    let mut entries = fs::read_dir(dir).await?;
-    
-    while let Some(entry) = entries.next_entry().await? {
-        let path = entry.path();
-        if path.extension().and_then(|s| s.to_str()) == Some("json") {
-            let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
-            if name.starts_with("events_") {
-                let content = fs::read_to_string(&path).await?;
-                let events: Vec<CompanyEvent> = serde_json::from_str(&content)?;
-                
-                for event in events {
-                    callback(event)?;
-                    total += 1;
-                }
-                
-                tokio::task::yield_now().await;
-            }
-        }
-    }
-    
-    logger::log_info(&format!("Corporate Storage: Streamed {} events", total)).await;
-    Ok(total)
-}
-
-/// Save events organized by month (accepts Vec, not HashMap)
-pub async fn save_optimized_events(
-    paths: &DataPaths, 
-    events: Vec<CompanyEvent>
-) -> anyhow::Result<()> {
-    let dir = paths.corporate_events_dir();
-    fs::create_dir_all(dir).await?;
-
-    logger::log_info("Corporate Storage: Removing old event files...").await;
-    let mut removed_count = 0;
-    let mut entries = fs::read_dir(dir).await?;
-    while let Some(entry) = entries.next_entry().await? {
-        let path = entry.path();
-        let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
-        if name.starts_with("events_") && path.extension().map(|e| e == "json").unwrap_or(false) {
-            fs::remove_file(&path).await?;
-            removed_count += 1;
-        }
-    }
-    logger::log_info(&format!("Corporate Storage: Removed {} old files", removed_count)).await;
-
-    let total_events = events.len();
-    let mut sorted = events;
-    sorted.sort_by(|a, b| {
-        a.ticker.cmp(&b.ticker).then(a.date.cmp(&b.date))
-    });
-
-    let mut by_month: HashMap<String, Vec<CompanyEvent>> = HashMap::new();
-    
-    for chunk in sorted.chunks(BATCH_SIZE) {
-        for e in chunk {
-            if let Ok(d) = NaiveDate::parse_from_str(&e.date, "%Y-%m-%d") {
-                let key = format!("{}-{:02}", d.year(), d.month());
-                by_month.entry(key).or_default().push(e.clone());
-            }
-        }
-        tokio::task::yield_now().await;
-    }
-
-    for (month, list) in by_month {
-        let path = dir.join(format!("events_{}.json", month));
-        fs::write(&path, serde_json::to_string_pretty(&list)?).await?;
-        logger::log_info(&format!("Saved {} events for month {}", list.len(), month)).await;
-    }
-    
-    logger::log_info(&format!("Saved {} total events", total_events)).await;
-    Ok(())
-}
-
-pub async fn save_changes(
-    paths: &DataPaths, 
-    changes: &[CompanyEventChange]
-) -> anyhow::Result<()> {
-    if changes.is_empty() { 
-        logger::log_info("Corporate Storage: No changes to save").await;
-        return Ok(()); 
-    }
-    
-    let dir = paths.corporate_changes_dir();
-    fs::create_dir_all(dir).await?;
-
-    let mut by_month: HashMap<String, Vec<CompanyEventChange>> = HashMap::new();
-    for c in changes {
-        if let Ok(d) = NaiveDate::parse_from_str(&c.date, "%Y-%m-%d") {
-            let key = format!("{}-{:02}", d.year(), d.month());
-            by_month.entry(key).or_default().push(c.clone());
-        }
-    }
-
-    for (month, list) in by_month {
-        let path = dir.join(format!("changes_{}.json", month));
-        let mut all = if path.exists() {
-            let s = fs::read_to_string(&path).await?;
-            serde_json::from_str(&s).unwrap_or_default()
-        } else { 
-            vec![] 
-        };
-        all.extend(list.clone());
-        fs::write(&path, serde_json::to_string_pretty(&all)?).await?;
-    }
-    
-    Ok(())
-}
-
-pub async fn save_prices_for_ticker(
-    paths: &DataPaths, 
-    ticker: &str, 
-    timeframe: &str, 
-    mut prices: Vec<CompanyPrice>
-) -> anyhow::Result<()> {
-    let base_dir = paths.corporate_prices_dir();
-    let company_dir = base_dir.join(ticker.replace(".", "_"));
-    let timeframe_dir = company_dir.join(timeframe);
-
-    fs::create_dir_all(&timeframe_dir).await?;
-    let path = timeframe_dir.join("prices.json");
-
-    prices.sort_by_key(|p| (p.date.clone(), p.time.clone()));
-    fs::write(&path, serde_json::to_string_pretty(&prices)?).await?;
-    Ok(())
-}
-
 pub fn get_company_dir(paths: &DataPaths, lei: &str) -> PathBuf {
     paths.corporate_prices_dir().join(lei)
 }
@@ -230,48 +72,6 @@ pub async fn ensure_company_dirs(paths: &DataPaths, isin: &str) -> anyhow::Resul
     Ok(())
 }
 
-pub async fn save_available_exchanges(
-    paths: &DataPaths, 
-    isin: &str, 
-    exchanges: Vec<AvailableExchange>
-) -> anyhow::Result<()> {
-    let dir = get_company_dir(paths, isin);
-    fs::create_dir_all(&dir).await?;
-    let path = dir.join("available_exchanges.json");
-    fs::write(&path, serde_json::to_string_pretty(&exchanges)?).await?;
-    Ok(())
-}
-
-pub async fn load_available_exchanges(
-    paths: &DataPaths, 
-    lei: &str
-) -> anyhow::Result<Vec<AvailableExchange>> {
-    let path = get_company_dir(paths, lei).join("available_exchanges.json");
-    if path.exists() {
-        let content = fs::read_to_string(&path).await?;
-        Ok(serde_json::from_str(&content)?)
-    } else {
-        Ok(vec![])
-    }
-}
-
-pub async fn save_prices_by_source(
-    paths: &DataPaths,
-    lei: &str,
-    source_ticker: &str,
-    timeframe: &str,
-    prices: Vec<CompanyPrice>,
-) -> anyhow::Result<()> {
-    let source_safe = source_ticker.replace(".", "_").replace("/", "_");
-    let dir = get_company_dir(paths, lei).join(timeframe).join(&source_safe);
-    fs::create_dir_all(&dir).await?;
-    let path = dir.join("prices.json");
-    let mut prices = prices;
-    prices.sort_by_key(|p| (p.date.clone(), p.time.clone()));
-    fs::write(&path, serde_json::to_string_pretty(&prices)?).await?;
-    Ok(())
-}
-
 /// Stream companies to JSONL incrementally
 pub async fn save_companies_to_jsonl_streaming(
     paths: &DataPaths,