webdavc 0.1.1

async webdav client. fork from rustydav https://docs.rs/rustydav
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

use quick_xml::name::QName;

#[derive(Debug, Clone)]
pub struct FileInfo {
    pub path: String,
    pub name: String,
    pub size: u64,
    pub is_dir: bool,
    pub file_type: String,
    pub create_date: String,
    pub modified_date: String,
}

pub fn parse_xml(src: &str) -> Result<Vec<FileInfo>, String> {
    let mut files = Vec::new();
    let mut reader = quick_xml::Reader::from_str(src);
    reader.trim_text(true);
    loop {
        match reader.read_event() {
            Ok(quick_xml::events::Event::Start(ref e)) if e.name() == QName(b"D:response") => {
                let mut file = FileInfo {
                    path: String::new(),
                    name: String::new(),
                    size: 0,
                    is_dir: true,
                    file_type: String::new(),
                    create_date: String::new(),
                    modified_date: String::new(),
                };
                loop {
                    match reader.read_event() {
                        Ok(quick_xml::events::Event::Start(ref e)) => {
                            if e.name() == QName(b"D:href") {
                                file.path = reader
                                    .read_text(e.name())
                                    .map_err(|x| x.to_string())?
                                    .to_string();
                                file.name = file.path.split('/').last().unwrap_or("").to_string();
                                file.file_type =
                                    file.name.split('.').last().unwrap_or("").to_string();
                            } else if e.name() == QName(b"lp1:getcontentlength") {
                                file.size = reader
                                    .read_text(e.name())
                                    .map_err(|x| x.to_string())?
                                    .to_string()
                                    .parse::<u64>()
                                    .map_err(|_| "Failed to parse size")?;
                                file.is_dir = false;
                            } else if e.name() == QName(b"lp1:creationdate") {
                                file.create_date = reader
                                    .read_text(e.name())
                                    .map_err(|x| x.to_string())?
                                    .to_string();
                            } else if e.name() == QName(b"lp1:getlastmodified") {
                                file.modified_date = reader
                                    .read_text(e.name())
                                    .map_err(|x| x.to_string())?
                                    .to_string();
                            }
                        }
                        Ok(quick_xml::events::Event::End(ref e)) => {
                            if e.name() == QName(b"D:response") {
                                files.push(file);
                                break;
                            }
                        }
                        Ok(quick_xml::events::Event::Eof) => return Ok(files),
                        Err(e) => return Err(e.to_string()),
                        _ => (),
                    }
                }
            }
            Ok(quick_xml::events::Event::Start(ref e)) => {}
            Ok(quick_xml::events::Event::Eof) => break,
            Err(e) => return Err(e.to_string()),
            _ => (),
        }
    }

    Ok(files)
}