dadk_user/parser/
task_log.rs1use chrono::{DateTime, Utc};
6use log::warn;
7use serde::{Deserialize, Deserializer, Serialize};
8
9#[derive(Debug, Clone, Serialize, Deserialize)]
11pub struct TaskLog {
12 #[serde(
14 deserialize_with = "ok_or_default",
15 skip_serializing_if = "Option::is_none"
16 )]
17 build_timestamp: Option<DateTime<Utc>>,
18 install_timestamp: Option<DateTime<Utc>>,
19 build_status: Option<BuildStatus>,
21 install_status: Option<InstallStatus>,
23 dadk_config_timestamp: Option<DateTime<Utc>>,
25}
26
27fn ok_or_default<'a, T, D>(deserializer: D) -> Result<T, D::Error>
28where
29 T: Deserialize<'a> + Default,
30 D: Deserializer<'a>,
31{
32 let r = Option::deserialize(deserializer).map(|x: Option<T>| x.unwrap_or_default());
33
34 Ok(r.unwrap_or_default())
35}
36
37impl TaskLog {
38 pub fn new() -> Self {
39 Self {
40 build_timestamp: None,
41 build_status: None,
42 install_timestamp: None,
43 install_status: None,
44 dadk_config_timestamp: None,
45 }
46 }
47
48 pub fn dadk_config_timestamp(&self) -> Option<&DateTime<Utc>> {
49 self.dadk_config_timestamp.as_ref()
50 }
51
52 pub fn set_dadk_config_timestamp(&mut self, time: DateTime<Utc>) {
53 self.dadk_config_timestamp = Some(time);
54 }
55
56 #[allow(dead_code)]
57 pub fn set_build_time(&mut self, time: DateTime<Utc>) {
58 self.build_timestamp = Some(time);
59 }
60
61 pub fn build_time(&self) -> Option<&DateTime<Utc>> {
62 self.build_timestamp.as_ref()
63 }
64
65 pub fn set_build_time_now(&mut self) {
66 self.build_timestamp = Some(Utc::now());
67 }
68
69 pub fn install_time(&self) -> Option<&DateTime<Utc>> {
70 self.install_timestamp.as_ref()
71 }
72
73 pub fn set_install_time_now(&mut self) {
74 self.install_timestamp = Some(Utc::now());
75 }
76
77 pub fn set_build_status(&mut self, status: BuildStatus) {
78 self.build_status = Some(status);
79 }
80
81 pub fn clean_build_status(&mut self) {
82 self.build_status = None;
83 }
84
85 pub fn build_status(&self) -> Option<&BuildStatus> {
86 self.build_status.as_ref()
87 }
88
89 pub fn install_status(&self) -> Option<&InstallStatus> {
90 self.install_status.as_ref()
91 }
92
93 pub fn set_install_status(&mut self, status: InstallStatus) {
94 self.install_status = Some(status);
95 }
96
97 pub fn clean_install_status(&mut self) {
98 self.install_status = None;
99 }
100}
101
102#[derive(Debug, Clone, Serialize, PartialEq)]
104pub enum BuildStatus {
105 #[serde(rename = "success")]
106 Success,
107 #[serde(rename = "failed")]
108 Failed,
109}
110
111impl<'de> Deserialize<'de> for BuildStatus {
112 fn deserialize<D>(deserializer: D) -> Result<BuildStatus, D::Error>
113 where
114 D: Deserializer<'de>,
115 {
116 let s = String::deserialize(deserializer)?.to_ascii_lowercase();
117 match s.as_str() {
118 "success" => Ok(BuildStatus::Success),
119 "failed" => Ok(BuildStatus::Failed),
120 _ => {
121 warn!("invalid build status: {}", s);
122 Ok(BuildStatus::Failed)
123 }
124 }
125 }
126}
127
128#[derive(Debug, Clone, Serialize, PartialEq)]
130pub enum InstallStatus {
131 #[serde(rename = "success")]
132 Success,
133 #[serde(rename = "failed")]
134 Failed,
135}
136
137impl<'de> Deserialize<'de> for InstallStatus {
138 fn deserialize<D>(deserializer: D) -> Result<InstallStatus, D::Error>
139 where
140 D: Deserializer<'de>,
141 {
142 let s = String::deserialize(deserializer)?.to_ascii_lowercase();
143 match s.as_str() {
144 "success" => Ok(InstallStatus::Success),
145 "failed" => Ok(InstallStatus::Failed),
146 _ => {
147 warn!("invalid install status: {}", s);
148 Ok(InstallStatus::Failed)
149 }
150 }
151 }
152}