boox-note-parser 0.2.0

A Rust library for parsing .note files from Onyx Boox e-ink devices.
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

use crate::{
    error::Result,
    id::{PageUuid, VirtualDocUuid},
    utils::{convert_timestamp_to_datetime, parse_json},
    virtual_doc::json::Content,
};

#[derive(Debug, Clone)]
pub struct VirtualDoc {
    pub virtual_doc_id: VirtualDocUuid,
    pub created: chrono::DateTime<chrono::Utc>,
    pub modified: chrono::DateTime<chrono::Utc>,
    pub page_id: PageUuid,
    pub stability: f32,
    pub content: Content,
}

impl VirtualDoc {
    pub fn read(mut reader: impl std::io::Read) -> Result<Self> {
        let doc = protobuf::VirtualDoc::read(&mut reader)?;
        Ok(Self {
            virtual_doc_id: VirtualDocUuid::from_str(&doc.virtual_doc_uuid)?,
            created: convert_timestamp_to_datetime(doc.created)?,
            modified: convert_timestamp_to_datetime(doc.modified)?,
            page_id: PageUuid::from_str(&doc.template_uuid)?,
            stability: doc.stability,
            content: parse_json(&doc.content_json)?,
        })
    }
}

mod json {
    use serde::Deserialize;

    use crate::json::Dimensions;

    #[derive(Debug, Clone, Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct Content {
        pub content_id: String,
        pub content_page_id: String,
        pub content_page_size: Dimensions,
        pub content_relative_path: String,
        pub content_type: String,
    }
}

mod protobuf {
    use prost::Message;

    use crate::error::Result;

    #[derive(Clone, PartialEq, Message)]
    pub struct VirtualDoc {
        // Confirmed
        #[prost(string, tag = "1")]
        pub virtual_doc_uuid: String,
        // Confirmed
        #[prost(uint64, tag = "2")]
        pub created: u64,
        // Confirmed
        #[prost(uint64, tag = "3")]
        pub modified: u64,
        // Confirmed
        #[prost(string, tag = "4")]
        pub template_uuid: String,
        // Uncertain
        #[prost(float, tag = "5")]
        pub stability: f32,
        // Uncertain
        #[prost(float, tag = "7")]
        pub unknown: f32,
        // Confirmed
        #[prost(string, tag = "9")]
        pub content_json: String,
    }

    impl VirtualDoc {
        pub fn read(mut reader: impl std::io::Read) -> Result<Self> {
            let mut buf = Vec::new();
            reader.read_to_end(&mut buf)?;
            Ok(VirtualDoc::decode(&buf[..])?)
        }
    }
}