Merge branch 'feat/groupped_report'

.gitignore

@@ -3,7 +3,9 @@ src/.env
 .env
 log/
 .zip
+.vscode
 evaluations
+groupped
 # Added by cargo
 #
 # already existing elements were commented out

Cargo.toml

@@ -3,6 +3,14 @@ name = "piperun-bot"
 version = "0.1.0"
 edition = "2024"
 
+[[bin]]
+name = "groupped_repport"
+path = "src/groupped_repport.rs"
+
+[[bin]]
+name = "piperun-bot"
+path = "src/main.rs"
+
 [dependencies]
 http = {version = "1.3.1"}
 dotenv = {version = "0.15.0"}
@@ -11,7 +19,11 @@ reqwest = { version = "0.12.23", features = ["json", "cookies", "blocking"] }
 chrono = { version = "0.4.42" }
 itertools = {version = "0.14.0"}
 ipaddress = {version = "0.1.3"}
-zip = { version = "5.1.1"}
+zip = { version = "6.0.0"}
 walkdir = { version = "2.5.0"}
-lettre = {version = "0.11.18", features = ["builder"]}
-anyhow = { version = "1.0.100"}
+lettre = {version = "0.11.19", features = ["builder"]}
+anyhow = { version = "1.0.100"}
+polars = { version = "0.51.0"}
+serde = { version = "1.0.228" }
+csv = {version = "1.4.0"}
+regex = { version = "1.12.2" }

PROMPT_DATA_SANITIZATION.txt

@@ -0,0 +1,111 @@
+Abaixo está a avaliação de um atendimento que foi realizado. Eu preciso que a formatação fique consistente e padronizada.
+Padronize o arquivo CSV da seguinte forma, deixando apenas as colunas listadas.
+Título: CATEGORIA;PONTOS
+A sua resposta deve ser apenas o CSV com a formatação corrigida, nada mais deve ser incluído na sua resposta, nem mesmo notas sobre a resposta.
+Se não for possível padronizar o arquivo de entrada de acordo com as instruções fornecidas a resposta deve ser o CSV com o campo de pontuação vazio.
+As categorias são: APRESENTAÇÃO, CONFIRMAÇÃO DE E-MAIL, CONFIRMAÇÃO DE TELEFONE, PROTOCOLO, USO DO PORTUGUÊS, PACIÊNCIA E EDUCAÇÃO, DISPONIBILIDADE, CONHECIMENTO TÉCNICO, DIDATISMO
+A coluna pontos deve ter apenas os valores 0, 1 ou vazio, se no arquivo de entrada não houver a avaliação da categoria, a columa de pontos deve ser vazia. 
+
+Aqui estão alguns exemplos de formatação de como deve ser a sua resposta:
+Exemplo 01:
+Dado o seguinte arquivo de entrada: 
+APRESENTAÇÃO;1;O agente se apresentou ao cliente.;Boa noite, me chamo Ander.;Certo, um bom final de semana! 😊  
+CONFIRMAÇÃO DE E-MAIL;1;O agente pediu confirmação do e-mail.;Para manter o cadastro atualizado, poderia me confirmar se o e-mail continua sendo janainads.sls@gmail.com e se o telefone do titular do cadastro permanece (53) 98446-2208?;Obrigado pela confirmação.  
+CONFIRMAÇÃO DE TELEFONE;1;O agente pediu confirmação do telefone.;Para manter o cadastro atualizado, poderia me confirmar se o e-mail continua sendo janainads.sls@gmail.com e se o telefone do titular do cadastro permanece (53) 98446-2208?;Obrigado pela confirmação.  
+PROTOCOLO;1;O agente informou o protocolo.;Aqui está o protocolo do teu atendimento: 2510.3624;Boa noite, me chamo Ander.  
+USO DO PORTUGUÊS;1;O agente utilizou português correto.;Aqui está o protocolo do teu atendimento: 2510.3624;Para manter o cadastro atualizado, poderia me confirmar se o e-mail continua sendo janainads.sls@gmail.com e se o telefone do titular do cadastro permanece (53) 98446-2208?  
+PACIÊNCIA E EDUCAÇÃO;1;O agente foi paciente e educado.;Obrigado pela confirmação.;Certo, um bom final de semana! 😊  
+DISPONIBILIDADE;1;O agente demonstrou disponibilidade.;Caso tenha alguma dúvida, nos contate. A equipe da NovaNet está sempre aqui para te ajudar.😊;Certo, um bom final de semana! 😊  
+CONHECIMENTO TÉCNICO;1;O agente identificou que não havia problemas nos equipamentos.;Verifiquei aqui os equipamentos e não identifiquei nenhum problema com eles.;A potência recebida pelo equipamento está normal e as configurações do roteador estão todas corretas.  
+DIDATISMO;1;O agente foi didático ao orientar o cliente.;Certo, tu poderia se conectar na rede do primeiro roteador e verificar se ocorre algum problema?;Entendi, pode ser algum problema neste segundo roteador, tu pode estar reiniciando ele na tomada para caso seja algum travamento.  
+100%
+
+A resposta sua deve ser:
+```csv
+CATEGORIA;PONTOS
+APRESENTAÇÃO;1
+CONFIRMAÇÃO DE E-MAIL;1
+CONFIRMAÇÃO DE TELEFONE;1
+PROTOCOLO;1
+USO DO PORTUGUÊS;1
+PACIÊNCIA E EDUCAÇÃO;1
+DISPONIBILIDADE;1
+CONHECIMENTO TÉCNICO;1
+DIDATISMO;1
+```
+
+Exemplo 02:
+Dado o seguinte arquivo de entrada:
+01,1,Apresentação,"Boa tarde, me chamo Ander. (12:10:05)"  
+02,1,Confirmou e‑mail,"Para manter o cadastro atualizado, poderia me confirmar se o e‑mail continua sendo mmaicomvoss@gmail.com? (13:01:40)"  
+03,1,Confirmou telefone,"para manter o cadastro atualizado, poderia me confirmar se o telefone continua (53) 98414‑3027? (13:01:40)"  
+04,1,Informa protocolo,"Aqui está o protocolo do teu atendimento: 2510.2749 (12:10:06)"  
+05,1,Uso correto do português,"Todas as mensagens foram escritas em português formal e correto, inclusive com 'tu' permitido. (12:10:05‑13:03:08)"  
+06,1,Uso de linguagem paciente e educada,"Aguarde meu retorno, por gentileza; me informe, por gentileza; obrigado pela confirmação. (12:10:13‑13:03:07)"  
+07,1,Disponibilidade expressa,"Caso tenha alguma dúvida, nos contate. A equipe da NovaNet está sempre aqui para te ajudar. (13:03:08)"  
+08,1,Conhecimento técnico,"Identificou mau contato no cabo, instruiu reconexões, avaliou ordem de serviço, cotou peças. (12:25:44‑12:57:10)"  
+09,1,Didático,"Desconecte o cabo LAN/WAN passo a passo e me informe quando terminar. (12:25:56‑12:26:06)"  
+10,1,Eclaração diagnóstica,"Fez diagnóstico de mau contato no cabo e ofereceu ordem de serviço sem custo. (12:55:17‑13:01:15)"  
+11,2,Tempo de espera excedido, 2 ocorrências,"Intervalos superiores a 5 min: 12:55:17‑13:01:15 (5 min 58 s) e 12:27:51‑12:54:11 (26 min 20 s)"
+
+A resposta sua deve ser:
+```csv
+CATEGORIA;PONTOS
+APRESENTAÇÃO;1
+CONFIRMAÇÃO DE E-MAIL;1
+CONFIRMAÇÃO DE TELEFONE;1
+PROTOCOLO;1
+USO DO PORTUGUÊS;1
+PACIÊNCIA E EDUCAÇÃO;1
+DISPONIBILIDADE;1
+CONHECIMENTO TÉCNICO;1
+DIDATISMO;1
+```
+
+Exemplo 03:
+Dado o seguinte arquivo de entrada:
+Identificação e abertura do atendimento,1,
+Confirmação de dados do cliente,1,
+Verificação do histórico e do plano do cliente,1,
+Análise e diagnóstico da falha na conectividade,1,
+Verificação e teste de equipamentos,1,
+Sugestão de solução de conectividade,1,
+Escala de serviço,1,
+Encerramento de atendimento,1,
+Follow-up,1,
+Comunicação com o cliente,1,
+Tempo de Resposta,1
+
+A sua resposta deve ser vazia neste caso, pois a entrada não fornece a pontuação adequada para os critérios. 
+Ou seja o retorno deve ser o seguinte
+```csv
+CATEGORIA;PONTOS
+APRESENTAÇÃO;
+CONFIRMAÇÃO DE E-MAIL;
+CONFIRMAÇÃO DE TELEFONE;
+PROTOCOLO;
+USO DO PORTUGUÊS;
+PACIÊNCIA E EDUCAÇÃO;
+DISPONIBILIDADE;
+CONHECIMENTO TÉCNICO;
+DIDATISMO;
+```
+
+
+Aqui um exemplo de formatação de como não deve ser sua resposta
+Erro 01: Não utilizar o formato estritamente como fornecido nas instruções e copiar da entrada que está sendo avaliada
+```csv
+CATEGORIA;PONTOS
+APRESENTAÇÃO;1
+Confirmação de e-mail;1
+CONFIRMAÇÃO DE TELEFONE;1
+PROTOCOLO;1
+USO DO PORTUGUÊS;1
+PACIÊNCIA E EDUCAÇÃO;1
+DISPONIBILIDADE;1
+CONHECIMENTO TÉCNICO;1
+DIDATISMO;1
+```
+
+Abaixo está a avaliação que deve ser processada
+--------------------------------

src/groupped_repport.rs

@@ -0,0 +1,380 @@
+use std::fmt::Debug;
+
+use itertools::Itertools;
+use polars::prelude::*;
+use reqwest;
+use std::env;
+use std::time::Duration;
+
+use csv;
+
+pub mod send_mail_util;
+pub mod zip_directory_util;
+
+#[derive(Debug, serde::Deserialize)]
+struct CsvHeader {
+    CATEGORIA: String,
+    PONTOS: Option<u8>,
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct CsvEvaluation {
+    APRESENTAÇÃO: u8,
+    CONFIRMAÇÃO_DE_EMAIL: u8,
+    CONFIRMAÇÃO_DE_TELEFONE: u8,
+    PROTOCOLO: u8,
+    USO_DO_PORTUGUÊS: u8,
+    PACIÊNCIA_E_EDUCAÇÃO: u8,
+    DISPONIBILIDADE: u8,
+    CONHECIMENTO_TÉCNICO: u8,
+    DIDATISMO: u8,
+    ID_TALK: String,
+}
+
+fn main() {
+    match dotenv::dotenv().ok() {
+        Some(_) => println!("Environment variables loaded from .env file"),
+        None => eprintln!("Failed to load .env file, using defaults"),
+    }
+
+    // Read environment variables
+    let OLLAMA_URL = env::var("OLLAMA_URL").unwrap_or("localhost".to_string());
+    let OLLAMA_PORT = env::var("OLLAMA_PORT")
+        .unwrap_or("11432".to_string())
+        .parse::<u16>()
+        .unwrap_or(11432);
+    let OLLAMA_AI_MODEL_DATA_SANITIZATION = env::var("OLLAMA_AI_MODEL_DATA_SANITIZATION")
+        .expect("Missing environment variable OLLAMA_AI_MODEL_DATA_SANITIZATION");
+    let BOT_EMAIL = env::var("BOT_EMAIL").expect("BOT_EMAIL has not been set!");
+    let BOT_EMAIL_PASSWORD =
+        env::var("BOT_EMAIL_PASSWORD").expect("BOT_EMAIL_PASSWORD has not been set!");
+
+    let ip_address = ipaddress::IPAddress::parse(OLLAMA_URL.to_string());
+    let OLLAMA_SANITIZED_IP = match ip_address {
+        Ok(ip) => {
+            if ip.is_ipv4() {
+                OLLAMA_URL.clone()
+            } else {
+                format!("[{}]", OLLAMA_URL.clone())
+            }
+        }
+        Err(e) => OLLAMA_URL.clone(),
+    };
+
+    // Get the current day in the format YYYY-MM-DD
+    let current_date = chrono::Local::now();
+    let formatted_date = current_date.format("%Y-%m-%d").to_string();
+
+    let current_date = chrono::Local::now();
+    let first_day_of_current_week = current_date
+        .date_naive()
+        .week(chrono::Weekday::Sun)
+        .first_day();
+    let current_date_minus_one_week = first_day_of_current_week
+        .checked_sub_days(chrono::Days::new(1))
+        .expect("Failed to subtract one day");
+    let first_day_of_last_week = current_date_minus_one_week
+        .week(chrono::Weekday::Sun)
+        .first_day();
+    let last_day_of_last_week = current_date_minus_one_week
+        .week(chrono::Weekday::Sun)
+        .last_day();
+
+    let previous_week_folder_names = std::fs::read_dir(std::path::Path::new("./evaluations"))
+        .expect("Failed to read directory ./evaluations")
+        .filter_map_ok(|entry| {
+            if entry.metadata().unwrap().is_dir() {
+                Some(entry.file_name())
+            } else {
+                None
+            }
+        })
+        .filter_map_ok(|entry_string_name| {
+            let regex_match_date =
+                regex::Regex::new(r"(\d{4}-\d{2}-\d{2})").expect("Failed to build regex");
+
+            let filename = entry_string_name.to_str().unwrap();
+            let matches_find = regex_match_date.find(filename);
+
+            match matches_find {
+                Some(found) => {
+                    let date = chrono::NaiveDate::parse_from_str(found.as_str(), "%Y-%m-%d");
+                    return Some((date.unwrap().week(chrono::Weekday::Sun), entry_string_name));
+                }
+                None => {
+                    return None;
+                }
+            };
+        })
+        .filter_map_ok(|(week, directory_string)| {
+            let first_day_of_week_in_folder_name = week.first_day();
+
+            if first_day_of_last_week == first_day_of_week_in_folder_name {
+                return Some(directory_string);
+            }
+            return None;
+        })
+        .filter_map(|value| {
+            if value.is_ok() {
+                return Some(value.unwrap());
+            } else {
+                return None;
+            }
+        })
+        .sorted()
+        .collect_vec();
+
+    println!("{:?}", previous_week_folder_names);
+
+    let prompt_data_sanitization = std::fs::read_to_string("./PROMPT_DATA_SANITIZATION.txt")
+        .expect("Failed to read PROMPT_DATA_SANITIZATION.txt");
+    let client = reqwest::blocking::Client::new();
+
+    let groupped_values = previous_week_folder_names
+        .iter()
+        .map(|folder_name| {
+            let folder_base_path = std::path::Path::new("./evaluations");
+            let folder_date_path = folder_base_path.join(folder_name);
+            std::fs::read_dir(folder_date_path)
+        })
+        .filter_map_ok(|files_inside_folder_on_date| {
+            let groupped_by_user_on_day = files_inside_folder_on_date
+                .filter_ok(|entry| {
+                    let entry_file_name_as_str = entry
+                        .file_name()
+                        .into_string()
+                        .expect("Failed to get filename as a String");
+
+                    entry_file_name_as_str.ends_with(".csv")
+                        && !entry_file_name_as_str.contains("response_time.csv")
+                })
+                .filter_map(|value| {
+                    if value.is_ok() {
+                        return Some(value.unwrap());
+                    }
+                    None
+                })
+                .map(|file_name_csv| {
+                    println!("{:?}", file_name_csv.path());
+                    let file_contents = std::fs::read_to_string(file_name_csv.path())
+                        .expect("Failed to read CSV file");
+
+                    let ollama_api_request = client
+                        .post(format!(
+                            "http://{OLLAMA_SANITIZED_IP}:{OLLAMA_PORT}/api/generate"
+                        ))
+                        .body(
+                            serde_json::json!({
+                                "model": OLLAMA_AI_MODEL_DATA_SANITIZATION,
+                                "prompt": format!("{prompt_data_sanitization} \n{file_contents}"),
+                                "temperature": 0.0, // Get predictable and reproducible output
+                                "stream": false,
+                            })
+                            .to_string(),
+                        );
+
+                    let result = ollama_api_request.timeout(Duration::from_secs(3600)).send();
+
+                    match result {
+                        Ok(response) => {
+                            println!("Response: {:?}", response);
+                            let response_json = response
+                                .json::<serde_json::Value>()
+                                .expect("Failed to deserialize response to JSON");
+                            let ai_response = response_json["response"]
+                                .as_str()
+                                .expect("Failed to get AI response as string");
+
+                            let ai_response = ai_response.to_string();
+
+                            let ai_response = if let Some(resp) = ai_response
+                                .strip_prefix(" ")
+                                .unwrap_or(&ai_response)
+                                .strip_prefix("```csv\n")
+                            {
+                                resp.to_string()
+                            } else {
+                                ai_response
+                            };
+                            let ai_response = if let Some(resp) = ai_response
+                                .strip_suffix(" ")
+                                .unwrap_or(&ai_response)
+                                .strip_suffix("```")
+                            {
+                                resp.to_string()
+                            } else {
+                                ai_response
+                            };
+
+                            return Ok((ai_response, file_name_csv));
+                        }
+                        Err(error) => {
+                            println!("Error {error}");
+                            return Err(error);
+                        }
+                    };
+                })
+                .filter_map_ok(|(ai_repsonse, file_path_csv)| {
+                    let mut reader = csv::ReaderBuilder::new()
+                        .has_headers(true)
+                        .delimiter(b';')
+                        .from_reader(ai_repsonse.as_bytes());
+
+                    let mut deserialized_iter = reader.deserialize::<CsvHeader>();
+
+                    let mut columns = deserialized_iter
+                        .filter_ok(|value| value.PONTOS.is_some())
+                        .map_ok(|value| {
+                            let col =
+                                Column::new(value.CATEGORIA.into(), [value.PONTOS.unwrap() as u32]);
+                            col
+                        })
+                        .filter_map(|value| {
+                            if value.is_ok() {
+                                return Some(value.unwrap());
+                            }
+                            None
+                        })
+                        .collect_vec();
+
+                    if columns.len() != 9 {
+                        return None;
+                    }
+
+                    // Parse id talk from file_path
+                    // filename example is: CC - Erraoander Quintana - 515578 - 20251020515578.csv
+                    // id talk is the last information, so in the example is: 20251020515578
+                    let regex_filename =
+                        regex::Regex::new(r"(CC - )((\w+\s*)+) - (\d+) - (\d+).csv").unwrap();
+
+                    let filename = file_path_csv
+                        .file_name()
+                        .into_string()
+                        .expect("Failed to convert file name as Rust &str");
+                    let found_regex_groups_in_filename = regex_filename
+                        .captures(filename.as_str())
+                        .expect("Failed to do regex capture");
+
+                    let user_name = found_regex_groups_in_filename
+                        .get(2)
+                        .expect("Failed to get the id from regex maches");
+                    let talk_id = found_regex_groups_in_filename
+                        .get(5)
+                        .expect("Failed to get the id from regex maches");
+
+                    columns.push(Column::new("ID_TALK".into(), [talk_id.clone().as_str()]));
+
+                    let df = polars::frame::DataFrame::new(columns)
+                        .expect("Failed to concatenate into a dataframe");
+
+                    // return a tuple with the dataframe and the user name, so it can be correctly merged after
+                    return Some((user_name.as_str().to_owned(), df));
+                })
+                .filter_map(|res| {
+                    if res.is_ok() {
+                        return Some(res.unwrap());
+                    }
+                    return None;
+                })
+                .into_group_map()
+                .into_iter()
+                .map(|(name, eval_dataframe_vec)| {
+                    let groupped_df = eval_dataframe_vec
+                        .iter()
+                        .cloned()
+                        .reduce(|acc, e| acc.vstack(&e).unwrap())
+                        .expect("Failed to concatenate dataframes");
+                    (name, groupped_df)
+                })
+                .into_group_map();
+
+            dbg!(&groupped_by_user_on_day);
+            return Some(groupped_by_user_on_day);
+        })
+        .filter_map(|res| {
+            if res.is_ok() {
+                return Some(res.unwrap());
+            }
+            return None;
+        })
+        .reduce(|mut acc, mut e| {
+            e.iter_mut().for_each(|(key, val)| {
+                if acc.contains_key(key) {
+                    acc.get_mut(key)
+                        .expect("Failed to obtain key that should already be present")
+                        .append(val);
+                } else {
+                    acc.insert(key.to_owned(), val.to_owned());
+                }
+            });
+            acc
+        })
+        .and_then(|groupped_hashmap_df| {
+            let result = groupped_hashmap_df
+                .iter()
+                .map(|(key, val)| {
+                    let dfs = val
+                        .iter()
+                        .cloned()
+                        .reduce(|acc, e| acc.vstack(&e).unwrap())
+                        .expect("Failed to concatenate dataframes");
+                    (key.clone(), dfs)
+                })
+                .collect_vec();
+            return Some(result);
+        });
+
+    // Setup groupped folder
+    if !std::fs::exists(format!("./groupped/")).unwrap() {
+        std::fs::create_dir(format!("./groupped")).expect("Failed to create directory")
+    }
+
+    // Setup previous week folder
+    if !std::fs::exists(format!(
+        "./groupped/{first_day_of_last_week} - {last_day_of_last_week}"
+    ))
+    .unwrap()
+    {
+        std::fs::create_dir(format!(
+            "./groupped/{first_day_of_last_week} - {last_day_of_last_week}"
+        ))
+        .expect("Failed to create directory")
+    }
+
+    match groupped_values {
+        Some(mut val) => {
+            val.iter_mut().for_each(|(agent, groupped_evaluations)| {
+                let mut save_file_csv = std::fs::File::create(format!(
+                    "./groupped/{first_day_of_last_week} - {last_day_of_last_week}/{agent}"
+                ))
+                .expect("Could not create csv file for saving");
+                CsvWriter::new(&mut save_file_csv)
+                    .include_header(true)
+                    .with_separator(b';')
+                    .finish(groupped_evaluations)
+                    .expect("Failed to save Groupped DataFrame to CSV File");
+            });
+        }
+        None => {}
+    }
+
+    zip_directory_util::zip_directory_util::zip_source_dir_to_dst_file(
+        std::path::Path::new(&format!(
+            "./groupped/{first_day_of_last_week} - {last_day_of_last_week}"
+        )),
+        std::path::Path::new(&format!(
+            "./groupped/{first_day_of_last_week} - {last_day_of_last_week}.zip"
+        )),
+    );
+
+    let recipients = "Wilson da Conceição Oliveira <wilson.oliveira@nova.net.br>, Isadora G. Moura de Moura <isadora.moura@nova.net.br>";
+    send_mail_util::send_mail_util::send_email(
+        &format!(
+            "Relatório agrupado dos atendimentos semana {first_day_of_last_week} - {last_day_of_last_week}"
+        ),
+        &BOT_EMAIL,
+        &BOT_EMAIL_PASSWORD,
+        recipients,
+        &format!("./groupped/{first_day_of_last_week} - {last_day_of_last_week}.zip"),
+    );
+}

src/send_mail_util.rs

@@ -0,0 +1,46 @@
+pub mod send_mail_util {
+    use lettre::{
+        Message, SmtpTransport, Transport,
+        message::{self, Attachment, Mailboxes, MultiPart, SinglePart, header::ContentType},
+    };
+
+    pub fn send_email(
+        subject_of_email: &str,
+        bot_email: &str,
+        bot_email_password: &str,
+        to: &str,
+        zip_file_name: &str,
+    ) {
+        let filebody = std::fs::read(zip_file_name).unwrap();
+        let content_type = ContentType::parse("application/zip").unwrap();
+        let attachment = Attachment::new(zip_file_name.to_string()).body(filebody, content_type);
+        let mailboxes: Mailboxes = to.parse().unwrap();
+        let to_header: message::header::To = mailboxes.into();
+
+        let email = Message::builder()
+            .from(format!("PipeRUN bot <{bot_email}>").parse().unwrap())
+            .reply_to(format!("PipeRUN bot <{bot_email}>").parse().unwrap())
+            .mailbox(to_header)
+            .subject(format!("{subject_of_email}"))
+            .multipart(
+                MultiPart::mixed()
+                    .singlepart(
+                        SinglePart::builder()
+                            .header(ContentType::TEXT_PLAIN)
+                            .body(String::from("Avaliacao dos atendimentos")),
+                    )
+                    .singlepart(attachment),
+            )
+            .unwrap();
+
+        // Create the SMTPS transport
+        let sender = SmtpTransport::from_url(&format!(
+            "smtps://{bot_email}:{bot_email_password}@mail.nova.net.br"
+        ))
+        .unwrap()
+        .build();
+
+        // Send the email via remote relay
+        sender.send(&email).unwrap();
+    }
+}

src/zip_directory_util.rs

@@ -0,0 +1,70 @@
+pub mod zip_directory_util {
+
+use std::io::prelude::*;
+use zip::write::SimpleFileOptions;
+
+use std::fs::File;
+use std::path::Path;
+use walkdir::{DirEntry, WalkDir};
+
+fn zip_dir<T>(
+    it: &mut dyn Iterator<Item = DirEntry>,
+    prefix: &Path,
+    writer: T,
+    method: zip::CompressionMethod,
+) where
+    T: Write + Seek,
+{
+    let mut zip = zip::ZipWriter::new(writer);
+    let options = SimpleFileOptions::default()
+        .compression_method(method)
+        .unix_permissions(0o755);
+
+    let prefix = Path::new(prefix);
+    let mut buffer = Vec::new();
+    for entry in it {
+        let path = entry.path();
+        let name = path.strip_prefix(prefix).unwrap();
+        let path_as_string = name
+            .to_str()
+            .map(str::to_owned)
+            .expect("Failed to parse path");
+
+        // Write file or directory explicitly
+        // Some unzip tools unzip files with directory paths correctly, some do not!
+        if path.is_file() {
+            println!("adding file {path:?} as {name:?} ...");
+            zip.start_file(path_as_string, options)
+                .expect("Failed to add file");
+            let mut f = File::open(path).unwrap();
+
+            f.read_to_end(&mut buffer).expect("Failed to read file");
+            zip.write_all(&buffer).expect("Failed to write file");
+            buffer.clear();
+        } else if !name.as_os_str().is_empty() {
+            // Only if not root! Avoids path spec / warning
+            // and mapname conversion failed error on unzip
+            println!("adding dir {path_as_string:?} as {name:?} ...");
+            zip.add_directory(path_as_string, options)
+                .expect("Failed to add directory");
+        }
+    }
+    zip.finish().expect("Failed to ZIP");
+}
+
+pub fn zip_source_dir_to_dst_file(src_dir: &Path, dst_file: &Path) {
+    if !Path::new(src_dir).is_dir() {
+        panic!("src_dir must be a directory");
+    }
+    
+    let method = zip::CompressionMethod::Stored;
+    let path = Path::new(dst_file);
+    let file = File::create(path).unwrap();
+
+    let walkdir = WalkDir::new(src_dir);
+    let it = walkdir.into_iter();
+
+    zip_dir(&mut it.filter_map(|e| e.ok()), src_dir, file, method);
+}
+
+}