nahpu_api 0.1.0

An CLI and API client for NAHPU scientific specimen cataloging application.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//! An archive writer module.
//!
//! Compresses and decompresses files to and from zip archives.
use std::{
    io::BufReader,
    path::{Path, PathBuf},
};

pub struct ZipArchive<'a> {
    /// The parent directory of the files to be archived.
    /// This is used to create the directory structure in the archive.
    pub parent_dir: &'a Path,
    /// Alternative parent directory to be used in the archive.
    /// This is used to create the directory structure
    /// if the parent directory is not present.
    pub alt_parent_dir: Option<&'a Path>,
    /// The files to be archived.
    pub files: &'a [PathBuf],
    /// The path to the output file.
    pub output_path: &'a Path,
}

/// A zip archive writer.
/// Writes the files to a zip archive.
/// The files are written to the archive with the directory structure
/// relative to the parent directory.
/// If the parent directory is not present, the alternative parent directory
/// is used to create the directory structure.
impl<'a> ZipArchive<'a> {
    pub fn new(
        parent_dir: &'a Path,
        alt_parent_dir: Option<&'a Path>,
        output_path: &'a Path,
        files: &'a [PathBuf],
    ) -> Self {
        Self {
            parent_dir,
            alt_parent_dir,
            files,
            output_path,
        }
    }

    pub fn write(&self) -> Result<(), std::io::Error> {
        let mut zip = zip::ZipWriter::new(std::fs::File::create(self.output_path).unwrap());
        let options =
            zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Deflated);

        for file in self.files {
            let file_path = self.parse_file_path(file);
            let inner = std::fs::File::open(file)?;
            let mut buff = BufReader::new(inner);
            zip.start_file(file_path, options)?;

            std::io::copy(&mut buff, &mut zip)?;
        }

        zip.finish()?;
        Ok(())
    }

    fn parse_file_path(&self, file: &Path) -> String {
        let file_name = Path::new(file.file_name().unwrap_or_else(|| {
            panic!("Failed parsing file name: {:?}", file);
        }));
        let prefix = file.strip_prefix(self.parent_dir);
        let file_path = match prefix {
            Ok(p) => p,
            // If the file is not in the parent directory,
            // use the alternative parent directory.
            // Otherwise, use the file name.
            Err(_) => file
                .strip_prefix(self.alt_parent_dir.unwrap_or(file_name))
                .unwrap_or(file_name),
        };
        file_path
            .to_str()
            .expect("Failed parsing file path")
            .to_string()
    }
}

pub struct ZipExtractor<'a> {
    /// The path to the zip archive.
    pub archive_path: &'a Path,
    /// The directory to extract the files to.
    pub output_dir: &'a Path,
}

/// A zip archive extractor.
/// Extracts the files from a zip archive.
/// The files are extracted to the output directory.
/// The directory structure is preserved.
impl<'a> ZipExtractor<'a> {
    pub fn new(archive_path: &'a Path, output_dir: &'a Path) -> Self {
        Self {
            archive_path,
            output_dir,
        }
    }

    pub fn extract(&self) -> Result<(), std::io::Error> {
        let file = std::fs::File::open(self.archive_path)?;
        let mut zip = zip::ZipArchive::new(file)?;

        zip.extract(self.output_dir)?;

        Ok(())
    }
}