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, canvas_lms_api_derive::CanvasResource)]
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 endpoint(&self) -> String {
37 format!("planner_notes/{}", self.id)
38 }
39
40 pub async fn delete(&self) -> Result<PlannerNote> {
44 let mut n: PlannerNote = self.req().delete(&self.endpoint(), &[]).await?;
45 n.requester = self.requester.clone();
46 Ok(n)
47 }
48
49 pub async fn update(&self, params: PlannerNoteParams) -> Result<PlannerNote> {
53 let flat: Vec<(String, String)> = serde_json::to_value(¶ms)
54 .unwrap_or_default()
55 .as_object()
56 .into_iter()
57 .flatten()
58 .filter_map(|(k, v)| {
59 v.as_str()
60 .map(|s| (k.clone(), s.to_string()))
61 .or_else(|| v.as_u64().map(|n| (k.clone(), n.to_string())))
62 })
63 .collect();
64 let mut n: PlannerNote = self.req().put(&self.endpoint(), &flat).await?;
65 n.requester = self.requester.clone();
66 Ok(n)
67 }
68}
69
70#[derive(Debug, Clone, Deserialize, Serialize, canvas_lms_api_derive::CanvasResource)]
73pub struct PlannerOverride {
74 pub id: u64,
75 pub plannable_type: Option<String>,
76 pub plannable_id: Option<u64>,
77 pub user_id: Option<u64>,
78 pub assignment_id: Option<u64>,
79 pub workflow_state: Option<String>,
80 pub marked_complete: Option<bool>,
81 pub dismissed: Option<bool>,
82 pub created_at: Option<String>,
83 pub updated_at: Option<String>,
84 pub deleted_at: Option<String>,
85 #[serde(skip)]
86 pub(crate) requester: Option<Arc<Requester>>,
87}
88
89#[derive(Debug, Clone, Default, Serialize)]
90pub struct PlannerOverrideParams {
91 #[serde(skip_serializing_if = "Option::is_none")]
92 pub marked_complete: Option<bool>,
93 #[serde(skip_serializing_if = "Option::is_none")]
94 pub dismissed: Option<bool>,
95}
96
97impl PlannerOverride {
98 fn endpoint(&self) -> String {
99 format!("planner/overrides/{}", self.id)
100 }
101
102 pub async fn delete(&self) -> Result<PlannerOverride> {
106 let mut o: PlannerOverride = self.req().delete(&self.endpoint(), &[]).await?;
107 o.requester = self.requester.clone();
108 Ok(o)
109 }
110
111 pub async fn update(&self, params: PlannerOverrideParams) -> Result<PlannerOverride> {
115 let mut flat: Vec<(String, String)> = vec![];
116 if let Some(mc) = params.marked_complete {
117 flat.push(("marked_complete".into(), mc.to_string()));
118 }
119 if let Some(d) = params.dismissed {
120 flat.push(("dismissed".into(), d.to_string()));
121 }
122 let mut o: PlannerOverride = self.req().put(&self.endpoint(), &flat).await?;
123 o.requester = self.requester.clone();
124 Ok(o)
125 }
126}