canvas_lms_api/resources/
planner.rs1use crate::error::Result;
2use crate::http::Requester;
3use serde::{Deserialize, Serialize};
4use std::sync::Arc;
5
6#[derive(Debug, Clone, Deserialize, Serialize)]
9pub struct PlannerNote {
10 pub id: u64,
11 pub title: Option<String>,
12 pub description: Option<String>,
13 pub user_id: Option<u64>,
14 pub workflow_state: Option<String>,
15 pub course_id: Option<u64>,
16 pub todo_date: Option<String>,
17 pub created_at: Option<String>,
18 pub updated_at: Option<String>,
19 #[serde(skip)]
20 pub(crate) requester: Option<Arc<Requester>>,
21}
22
23#[derive(Debug, Clone, Default, Serialize)]
24pub struct PlannerNoteParams {
25 #[serde(skip_serializing_if = "Option::is_none")]
26 pub title: Option<String>,
27 #[serde(skip_serializing_if = "Option::is_none")]
28 pub details: Option<String>,
29 #[serde(skip_serializing_if = "Option::is_none")]
30 pub todo_date: Option<String>,
31 #[serde(skip_serializing_if = "Option::is_none")]
32 pub course_id: Option<u64>,
33}
34
35impl PlannerNote {
36 fn req(&self) -> &Arc<Requester> {
37 self.requester.as_ref().expect("requester not injected")
38 }
39
40 fn endpoint(&self) -> String {
41 format!("planner_notes/{}", self.id)
42 }
43
44 pub async fn delete(&self) -> Result<PlannerNote> {
48 let mut n: PlannerNote = self.req().delete(&self.endpoint(), &[]).await?;
49 n.requester = self.requester.clone();
50 Ok(n)
51 }
52
53 pub async fn update(&self, params: PlannerNoteParams) -> Result<PlannerNote> {
57 let flat: Vec<(String, String)> = serde_json::to_value(¶ms)
58 .unwrap_or_default()
59 .as_object()
60 .into_iter()
61 .flatten()
62 .filter_map(|(k, v)| {
63 v.as_str()
64 .map(|s| (k.clone(), s.to_string()))
65 .or_else(|| v.as_u64().map(|n| (k.clone(), n.to_string())))
66 })
67 .collect();
68 let mut n: PlannerNote = self.req().put(&self.endpoint(), &flat).await?;
69 n.requester = self.requester.clone();
70 Ok(n)
71 }
72}
73
74#[derive(Debug, Clone, Deserialize, Serialize)]
77pub struct PlannerOverride {
78 pub id: u64,
79 pub plannable_type: Option<String>,
80 pub plannable_id: Option<u64>,
81 pub user_id: Option<u64>,
82 pub assignment_id: Option<u64>,
83 pub workflow_state: Option<String>,
84 pub marked_complete: Option<bool>,
85 pub dismissed: Option<bool>,
86 pub created_at: Option<String>,
87 pub updated_at: Option<String>,
88 pub deleted_at: Option<String>,
89 #[serde(skip)]
90 pub(crate) requester: Option<Arc<Requester>>,
91}
92
93#[derive(Debug, Clone, Default, Serialize)]
94pub struct PlannerOverrideParams {
95 #[serde(skip_serializing_if = "Option::is_none")]
96 pub marked_complete: Option<bool>,
97 #[serde(skip_serializing_if = "Option::is_none")]
98 pub dismissed: Option<bool>,
99}
100
101impl PlannerOverride {
102 fn req(&self) -> &Arc<Requester> {
103 self.requester.as_ref().expect("requester not injected")
104 }
105
106 fn endpoint(&self) -> String {
107 format!("planner/overrides/{}", self.id)
108 }
109
110 pub async fn delete(&self) -> Result<PlannerOverride> {
114 let mut o: PlannerOverride = self.req().delete(&self.endpoint(), &[]).await?;
115 o.requester = self.requester.clone();
116 Ok(o)
117 }
118
119 pub async fn update(&self, params: PlannerOverrideParams) -> Result<PlannerOverride> {
123 let mut flat: Vec<(String, String)> = vec![];
124 if let Some(mc) = params.marked_complete {
125 flat.push(("marked_complete".into(), mc.to_string()));
126 }
127 if let Some(d) = params.dismissed {
128 flat.push(("dismissed".into(), d.to_string()));
129 }
130 let mut o: PlannerOverride = self.req().put(&self.endpoint(), &flat).await?;
131 o.requester = self.requester.clone();
132 Ok(o)
133 }
134}